Running phase: unpackPhase unpacking source archive /nix/store/cldr063v1fwx3snww48ynv0fy9nxwa80-source source root is source Running phase: patchPhase Running phase: updateAutotoolsGnuConfigScriptsPhase Running phase: configurePhase no configure script, doing nothing Running phase: buildPhase build flags: SHELL=/nix/store/11ciq72n4fdv8rw6wgjgasfv4mjs1jrw-bash-5.2p37/bin/bash gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o absmach.o absmach.c In file included from absmach.c:46: absmach.c: In function 'iphrase': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1297:3: note: in expansion of macro 'apush' 1297 | apush(z); | ^~~~~ In file included from absmach.c:45: lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1297:3: note: in expansion of macro 'apush' 1297 | apush(z); | ^~~~~ absmach.c: In function 'ifault': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1316:5: note: in expansion of macro 'apush' 1316 | apush(makefault("?empty fault not allowed")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1316:5: note: in expansion of macro 'apush' 1316 | apush(makefault("?empty fault not allowed")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1324:7: note: in expansion of macro 'apush' 1324 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1324:7: note: in expansion of macro 'apush' 1324 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1327:5: note: in expansion of macro 'apush' 1327 | apush(makefault("?type error in fault")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1327:5: note: in expansion of macro 'apush' 1327 | apush(makefault("?type error in fault")); | ^~~~~ absmach.c: In function 'mklist': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1495:5: note: in expansion of macro 'apush' 1495 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1495:5: note: in expansion of macro 'apush' 1495 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1519:9: note: in expansion of macro 'apush' 1519 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1519:9: note: in expansion of macro 'apush' 1519 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1528:5: note: in expansion of macro 'apush' 1528 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1528:5: note: in expansion of macro 'apush' 1528 | apush(z); | ^~~~~ absmach.c: In function 'istatus': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:1576:3: note: in expansion of macro 'apush' 1576 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:1576:3: note: in expansion of macro 'apush' 1576 | apush(z); | ^~~~~ absmach.c: In function 'mkstring': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:2043:5: note: in expansion of macro 'apush' 2043 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:2043:5: note: in expansion of macro 'apush' 2043 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:2052:5: note: in expansion of macro 'apush' 2052 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:2052:5: note: in expansion of macro 'apush' 2052 | apush(z); | ^~~~~ absmach.c: In function 'mknstring': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:2064:5: note: in expansion of macro 'apush' 2064 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:2064:5: note: in expansion of macro 'apush' 2064 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:2079:7: note: in expansion of macro 'apush' 2079 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:2079:7: note: in expansion of macro 'apush' 2079 | apush(z); | ^~~~~ absmach.c: In function 'buildfault': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ absmach.c:2102:3: note: in expansion of macro 'apush' 2102 | apush(makefault(gcharbuf)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ absmach.c:2102:3: note: in expansion of macro 'apush' 2102 | apush(makefault(gcharbuf)); | ^~~~~ gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o arith.o arith.c In file included from arith.c:31: arith.c: In function 'nial_plus': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:259:3: note: in expansion of macro 'apush' 259 | apush(z); | ^~~~~ In file included from arith.c:30: lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:259:3: note: in expansion of macro 'apush' 259 | apush(z); | ^~~~~ arith.c: In function 'isum': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:279:9: note: in expansion of macro 'apush' 279 | apush(createint(sumbools(x, tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:279:9: note: in expansion of macro 'apush' 279 | apush(createint(sumbools(x, tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:286:13: note: in expansion of macro 'apush' 286 | apush(createint(res)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:286:13: note: in expansion of macro 'apush' 286 | apush(createint(res)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:289:13: note: in expansion of macro 'apush' 289 | apush(makefault("?Integer overflow")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:289:13: note: in expansion of macro 'apush' 289 | apush(makefault("?Integer overflow")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:294:9: note: in expansion of macro 'apush' 294 | apush(createreal(sumreals(pfirstreal(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:294:9: note: in expansion of macro 'apush' 294 | apush(createreal(sumreals(pfirstreal(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:298:9: note: in expansion of macro 'apush' 298 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:298:9: note: in expansion of macro 'apush' 298 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:301:9: note: in expansion of macro 'apush' 301 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:301:9: note: in expansion of macro 'apush' 301 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:314:11: note: in expansion of macro 'apush' 314 | apush(Zero); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:314:11: note: in expansion of macro 'apush' 314 | apush(Zero); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:326:13: note: in expansion of macro 'apush' 326 | apush(testfaults(x, Arith)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:326:13: note: in expansion of macro 'apush' 326 | apush(testfaults(x, Arith)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:329:13: note: in expansion of macro 'apush' 329 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:329:13: note: in expansion of macro 'apush' 329 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:334:11: note: in expansion of macro 'apush' 334 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:334:11: note: in expansion of macro 'apush' 334 | apush(x); | ^~~~~ arith.c: In function 'nial_times': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:610:3: note: in expansion of macro 'apush' 610 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:610:3: note: in expansion of macro 'apush' 610 | apush(z); | ^~~~~ arith.c: In function 'iproduct': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:634:9: note: in expansion of macro 'apush' 634 | apush(createint(prodbools(x, tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:634:9: note: in expansion of macro 'apush' 634 | apush(createint(prodbools(x, tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:641:13: note: in expansion of macro 'apush' 641 | apush(createint(res)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:641:13: note: in expansion of macro 'apush' 641 | apush(createint(res)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:644:13: note: in expansion of macro 'apush' 644 | apush(makefault("?Integer overflow")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:644:13: note: in expansion of macro 'apush' 644 | apush(makefault("?Integer overflow")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:649:9: note: in expansion of macro 'apush' 649 | apush(createreal(prodreals(pfirstreal(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:649:9: note: in expansion of macro 'apush' 649 | apush(createreal(prodreals(pfirstreal(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:654:9: note: in expansion of macro 'apush' 654 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:654:9: note: in expansion of macro 'apush' 654 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:657:9: note: in expansion of macro 'apush' 657 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:657:9: note: in expansion of macro 'apush' 657 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:670:11: note: in expansion of macro 'apush' 670 | apush(One); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:670:11: note: in expansion of macro 'apush' 670 | apush(One); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:682:13: note: in expansion of macro 'apush' 682 | apush(testfaults(x, Arith)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:682:13: note: in expansion of macro 'apush' 682 | apush(testfaults(x, Arith)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:685:13: note: in expansion of macro 'apush' 685 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:685:13: note: in expansion of macro 'apush' 685 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:690:11: note: in expansion of macro 'apush' 690 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:690:11: note: in expansion of macro 'apush' 690 | apush(x); | ^~~~~ arith.c: In function 'iplus': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:709:5: note: in expansion of macro 'apush' 709 | apush(makefault("?plus expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:709:5: note: in expansion of macro 'apush' 709 | apush(makefault("?plus expects a pair")); | ^~~~~ arith.c: In function 'itimes': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:732:5: note: in expansion of macro 'apush' 732 | apush(makefault("?times expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:732:5: note: in expansion of macro 'apush' 732 | apush(makefault("?times expects a pair")); | ^~~~~ arith.c: In function 'nial_minus': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1005:3: note: in expansion of macro 'apush' 1005 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1005:3: note: in expansion of macro 'apush' 1005 | apush(z); | ^~~~~ arith.c: In function 'iminus': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1026:5: note: in expansion of macro 'apush' 1026 | apush(makefault("?minus expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1026:5: note: in expansion of macro 'apush' 1026 | apush(makefault("?minus expects a pair")); | ^~~~~ arith.c: In function 'nial_divide': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1248:3: note: in expansion of macro 'apush' 1248 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1248:3: note: in expansion of macro 'apush' 1248 | apush(z); | ^~~~~ arith.c: In function 'idivide': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1266:5: note: in expansion of macro 'apush' 1266 | apush(makefault("?divide expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1266:5: note: in expansion of macro 'apush' 1266 | apush(makefault("?divide expects a pair")); | ^~~~~ arith.c: In function 'iabs': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1323:9: note: in expansion of macro 'apush' 1323 | apush(boolstoints(x)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1323:9: note: in expansion of macro 'apush' 1323 | apush(boolstoints(x)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1329:9: note: in expansion of macro 'apush' 1329 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1329:9: note: in expansion of macro 'apush' 1329 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1335:9: note: in expansion of macro 'apush' 1335 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1335:9: note: in expansion of macro 'apush' 1335 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1340:11: note: in expansion of macro 'apush' 1340 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1340:11: note: in expansion of macro 'apush' 1340 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1348:9: note: in expansion of macro 'apush' 1348 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1348:9: note: in expansion of macro 'apush' 1348 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1351:9: note: in expansion of macro 'apush' 1351 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1351:9: note: in expansion of macro 'apush' 1351 | apush(x); | ^~~~~ arith.c: In function 'ifloor': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1398:9: note: in expansion of macro 'apush' 1398 | apush(boolstoints(x)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1398:9: note: in expansion of macro 'apush' 1398 | apush(boolstoints(x)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1402:9: note: in expansion of macro 'apush' 1402 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1402:9: note: in expansion of macro 'apush' 1402 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1407:11: note: in expansion of macro 'apush' 1407 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1407:11: note: in expansion of macro 'apush' 1407 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1413:11: note: in expansion of macro 'apush' 1413 | apush(makefault("?Integer overflow")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1413:11: note: in expansion of macro 'apush' 1413 | apush(makefault("?Integer overflow")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1419:11: note: in expansion of macro 'apush' 1419 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1419:11: note: in expansion of macro 'apush' 1419 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1426:9: note: in expansion of macro 'apush' 1426 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1426:9: note: in expansion of macro 'apush' 1426 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1429:9: note: in expansion of macro 'apush' 1429 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1429:9: note: in expansion of macro 'apush' 1429 | apush(x); | ^~~~~ arith.c: In function 'itype': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1464:11: note: in expansion of macro 'apush' 1464 | apush(False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1464:11: note: in expansion of macro 'apush' 1464 | apush(False_val); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1467:11: note: in expansion of macro 'apush' 1467 | apush(Zero); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1467:11: note: in expansion of macro 'apush' 1467 | apush(Zero); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1470:11: note: in expansion of macro 'apush' 1470 | apush(Zeror); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1470:11: note: in expansion of macro 'apush' 1470 | apush(Zeror); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1473:11: note: in expansion of macro 'apush' 1473 | apush(Blank); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1473:11: note: in expansion of macro 'apush' 1473 | apush(Blank); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1476:11: note: in expansion of macro 'apush' 1476 | apush(Typicalphrase); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1476:11: note: in expansion of macro 'apush' 1476 | apush(Typicalphrase); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1479:11: note: in expansion of macro 'apush' 1479 | apush(Cipher); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1479:11: note: in expansion of macro 'apush' 1479 | apush(Cipher); | ^~~~~ arith.c: In function 'ichar': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1502:11: note: in expansion of macro 'apush' 1502 | apush(createchar((char) intval(x))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1502:11: note: in expansion of macro 'apush' 1502 | apush(createchar((char) intval(x))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1508:11: note: in expansion of macro 'apush' 1508 | apush(makefault("?not an integer")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1508:11: note: in expansion of macro 'apush' 1508 | apush(makefault("?not an integer")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1511:11: note: in expansion of macro 'apush' 1511 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1511:11: note: in expansion of macro 'apush' 1511 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1524:5: note: in expansion of macro 'apush' 1524 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1524:5: note: in expansion of macro 'apush' 1524 | apush(z); | ^~~~~ arith.c: In function 'icharrep': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1548:13: note: in expansion of macro 'apush' 1548 | apush(createint((nialint) c)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1548:13: note: in expansion of macro 'apush' 1548 | apush(createint((nialint) c)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1555:11: note: in expansion of macro 'apush' 1555 | apush(makefault("?not a character")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1555:11: note: in expansion of macro 'apush' 1555 | apush(makefault("?not a character")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1559:11: note: in expansion of macro 'apush' 1559 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1559:11: note: in expansion of macro 'apush' 1559 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1579:5: note: in expansion of macro 'apush' 1579 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1579:5: note: in expansion of macro 'apush' 1579 | apush(z); | ^~~~~ arith.c: In function 'ipower': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1678:5: note: in expansion of macro 'apush' 1678 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1678:5: note: in expansion of macro 'apush' 1678 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1682:5: note: in expansion of macro 'apush' 1682 | apush(makefault("?power expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1682:5: note: in expansion of macro 'apush' 1682 | apush(makefault("?power expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1696:15: note: in expansion of macro 'apush' 1696 | apush(One); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1696:15: note: in expansion of macro 'apush' 1696 | apush(One); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1699:15: note: in expansion of macro 'apush' 1699 | apush(createint(boolval(x0))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1699:15: note: in expansion of macro 'apush' 1699 | apush(createint(boolval(x0))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1716:21: note: in expansion of macro 'apush' 1716 | { apush(Divzero); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1716:21: note: in expansion of macro 'apush' 1716 | { apush(Divzero); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1718:21: note: in expansion of macro 'apush' 1718 | { apush(createreal(1.0 / y)); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1718:21: note: in expansion of macro 'apush' 1718 | { apush(createreal(1.0 / y)); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1721:19: note: in expansion of macro 'apush' 1721 | { apush(createreal(y)); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1721:19: note: in expansion of macro 'apush' 1721 | { apush(createreal(y)); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1726:13: note: in expansion of macro 'apush' 1726 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1726:13: note: in expansion of macro 'apush' 1726 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1729:13: note: in expansion of macro 'apush' 1729 | apush(x0); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1729:13: note: in expansion of macro 'apush' 1729 | apush(x0); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1741:11: note: in expansion of macro 'apush' 1741 | apush(One); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1741:11: note: in expansion of macro 'apush' 1741 | apush(One); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1744:11: note: in expansion of macro 'apush' 1744 | apush(createint(fetch_bool(x, 0))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1744:11: note: in expansion of macro 'apush' 1744 | apush(createint(fetch_bool(x, 0))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1758:15: note: in expansion of macro 'apush' 1758 | { apush(makefault("?Integer overflow")); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1758:15: note: in expansion of macro 'apush' 1758 | { apush(makefault("?Integer overflow")); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1762:17: note: in expansion of macro 'apush' 1762 | { apush(Divzero); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1762:17: note: in expansion of macro 'apush' 1762 | { apush(Divzero); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1764:17: note: in expansion of macro 'apush' 1764 | { apush(createreal(1.0 / n)); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1764:17: note: in expansion of macro 'apush' 1764 | { apush(createreal(1.0 / n)); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1767:15: note: in expansion of macro 'apush' 1767 | { apush(createint((nialint) floor(n))); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1767:15: note: in expansion of macro 'apush' 1767 | { apush(createint((nialint) floor(n))); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1778:15: note: in expansion of macro 'apush' 1778 | apush(Zeror); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1778:15: note: in expansion of macro 'apush' 1778 | apush(Zeror); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1781:15: note: in expansion of macro 'apush' 1781 | apush(createreal(1.0)); /* for consistency */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1781:15: note: in expansion of macro 'apush' 1781 | apush(createreal(1.0)); /* for consistency */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1787:13: note: in expansion of macro 'apush' 1787 | apush(createreal(r)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1787:13: note: in expansion of macro 'apush' 1787 | apush(createreal(r)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1791:15: note: in expansion of macro 'apush' 1791 | apush(createreal(r0)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1791:15: note: in expansion of macro 'apush' 1791 | apush(createreal(r0)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1792:15: note: in expansion of macro 'apush' 1792 | apush(createint(entier(r1))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1792:15: note: in expansion of macro 'apush' 1792 | apush(createint(entier(r1))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1796:15: note: in expansion of macro 'apush' 1796 | apush(makefault("?power")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1796:15: note: in expansion of macro 'apush' 1796 | apush(makefault("?power")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1799:13: note: in expansion of macro 'apush' 1799 | apush(makefault("?power")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1799:13: note: in expansion of macro 'apush' 1799 | apush(makefault("?power")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1803:9: note: in expansion of macro 'apush' 1803 | apush(Arith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1803:9: note: in expansion of macro 'apush' 1803 | apush(Arith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1808:15: note: in expansion of macro 'apush' 1808 | { apush(testbinfaults(x, Arith, false)); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1808:15: note: in expansion of macro 'apush' 1808 | { apush(testbinfaults(x, Arith, false)); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1810:15: note: in expansion of macro 'apush' 1810 | { apush(Arith); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1810:15: note: in expansion of macro 'apush' 1810 | { apush(Arith); } | ^~~~~ arith.c: In function 'b_quotient': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1945:3: note: in expansion of macro 'apush' 1945 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1945:3: note: in expansion of macro 'apush' 1945 | apush(z); | ^~~~~ arith.c: In function 'iquotient': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1963:5: note: in expansion of macro 'apush' 1963 | apush(makefault("?quotient expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1963:5: note: in expansion of macro 'apush' 1963 | apush(makefault("?quotient expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1970:5: note: in expansion of macro 'apush' 1970 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1970:5: note: in expansion of macro 'apush' 1970 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:1971:5: note: in expansion of macro 'apush' 1971 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:1971:5: note: in expansion of macro 'apush' 1971 | apush(y); | ^~~~~ arith.c: In function 'b_mod': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2150:3: note: in expansion of macro 'apush' 2150 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2150:3: note: in expansion of macro 'apush' 2150 | apush(z); | ^~~~~ arith.c: In function 'imod': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2168:5: note: in expansion of macro 'apush' 2168 | apush(makefault("?mod expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2168:5: note: in expansion of macro 'apush' 2168 | apush(makefault("?mod expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2175:5: note: in expansion of macro 'apush' 2175 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2175:5: note: in expansion of macro 'apush' 2175 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2176:5: note: in expansion of macro 'apush' 2176 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2176:5: note: in expansion of macro 'apush' 2176 | apush(y); | ^~~~~ arith.c: In function 'iseed': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2259:5: note: in expansion of macro 'apush' 2259 | apush(createreal(frandx / M)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2259:5: note: in expansion of macro 'apush' 2259 | apush(createreal(frandx / M)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2263:5: note: in expansion of macro 'apush' 2263 | apush(makefault("?fseed requires a real argument")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2263:5: note: in expansion of macro 'apush' 2263 | apush(makefault("?fseed requires a real argument")); | ^~~~~ arith.c: In function 'irandom': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2286:7: note: in expansion of macro 'apush' 2286 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2286:7: note: in expansion of macro 'apush' 2286 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2287:7: note: in expansion of macro 'apush' 2287 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2287:7: note: in expansion of macro 'apush' 2287 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2294:7: note: in expansion of macro 'apush' 2294 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2294:7: note: in expansion of macro 'apush' 2294 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2297:7: note: in expansion of macro 'apush' 2297 | apush(makefault("?invalid arg in random")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2297:7: note: in expansion of macro 'apush' 2297 | apush(makefault("?invalid arg in random")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ arith.c:2300:5: note: in expansion of macro 'apush' 2300 | apush(makefault("?invalid arg in random")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ arith.c:2300:5: note: in expansion of macro 'apush' 2300 | apush(makefault("?invalid arg in random")); | ^~~~~ gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o atops.o atops.c In file included from atops.c:32: atops.c: In function 'ishape': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:84:7: note: in expansion of macro 'apush' 84 | { apush(Null); } | ^~~~~ In file included from atops.c:35: lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:84:7: note: in expansion of macro 'apush' 84 | { apush(Null); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:106:5: note: in expansion of macro 'apush' 106 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:106:5: note: in expansion of macro 'apush' 106 | apush(z); | ^~~~~ atops.c: In function 'ifirst': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:147:3: note: in expansion of macro 'apush' 147 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:147:3: note: in expansion of macro 'apush' 147 | apush(z); | ^~~~~ atops.c: In function 'nial_solitary': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:172:3: note: in expansion of macro 'apush' 172 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:172:3: note: in expansion of macro 'apush' 172 | apush(z); | ^~~~~ atops.c: In function 'irest': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:218:3: note: in expansion of macro 'apush' 218 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:218:3: note: in expansion of macro 'apush' 218 | apush(z); | ^~~~~ atops.c: In function 'iappend': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:248:5: note: in expansion of macro 'apush' 248 | apush(makefault("?argument of append must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:248:5: note: in expansion of macro 'apush' 248 | apush(makefault("?argument of append must be a pair")); | ^~~~~ atops.c: In function 'append': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:302:3: note: in expansion of macro 'apush' 302 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:302:3: note: in expansion of macro 'apush' 302 | apush(z); | ^~~~~ atops.c: In function 'ihitch': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:331:5: note: in expansion of macro 'apush' 331 | apush(makefault("?argument of hitch must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:331:5: note: in expansion of macro 'apush' 331 | apush(makefault("?argument of hitch must be a pair")); | ^~~~~ atops.c: In function 'hitch': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:384:3: note: in expansion of macro 'apush' 384 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:384:3: note: in expansion of macro 'apush' 384 | apush(z); | ^~~~~ atops.c: In function 'b_reshape': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:433:5: note: in expansion of macro 'apush' 433 | apush(makefault("?shape")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:433:5: note: in expansion of macro 'apush' 433 | apush(makefault("?shape")); | ^~~~~ atops.c: In function 'ireshape': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:452:5: note: in expansion of macro 'apush' 452 | apush(makefault("?argument of reshape must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:452:5: note: in expansion of macro 'apush' 452 | apush(makefault("?argument of reshape must be a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:461:7: note: in expansion of macro 'apush' 461 | apush(makefault("?shape")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:461:7: note: in expansion of macro 'apush' 461 | apush(makefault("?shape")); | ^~~~~ atops.c: In function 'reshape': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:507:7: note: in expansion of macro 'apush' 507 | apush(makefault("?fill")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:507:7: note: in expansion of macro 'apush' 507 | apush(makefault("?fill")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:513:7: note: in expansion of macro 'apush' 513 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:513:7: note: in expansion of macro 'apush' 513 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:579:5: note: in expansion of macro 'apush' 579 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:579:5: note: in expansion of macro 'apush' 579 | apush(z); | ^~~~~ atops.c: In function 'isingle': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:616:5: note: in expansion of macro 'apush' 616 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:616:5: note: in expansion of macro 'apush' 616 | apush(z); | ^~~~~ atops.c: In function 'ilist': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:643:7: note: in expansion of macro 'apush' 643 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:643:7: note: in expansion of macro 'apush' 643 | apush(z); | ^~~~~ atops.c: In function 'pair': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:684:3: note: in expansion of macro 'apush' 684 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:684:3: note: in expansion of macro 'apush' 684 | apush(z); | ^~~~~ atops.c: In function 'iisboolean': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:696:3: note: in expansion of macro 'apush' 696 | apush(atomic(x) && kind(x) == booltype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:696:3: note: in expansion of macro 'apush' 696 | apush(atomic(x) && kind(x) == booltype ? True_val : False_val); | ^~~~~ atops.c: In function 'iisinteger': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:705:3: note: in expansion of macro 'apush' 705 | apush(atomic(x) && kind(x) == inttype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:705:3: note: in expansion of macro 'apush' 705 | apush(atomic(x) && kind(x) == inttype ? True_val : False_val); | ^~~~~ atops.c: In function 'iisreal': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:714:3: note: in expansion of macro 'apush' 714 | apush(atomic(x) && kind(x) == realtype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:714:3: note: in expansion of macro 'apush' 714 | apush(atomic(x) && kind(x) == realtype ? True_val : False_val); | ^~~~~ atops.c: In function 'iischar': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:723:3: note: in expansion of macro 'apush' 723 | apush(atomic(x) && kind(x) == chartype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:723:3: note: in expansion of macro 'apush' 723 | apush(atomic(x) && kind(x) == chartype ? True_val : False_val); | ^~~~~ atops.c: In function 'iisphrase': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:732:3: note: in expansion of macro 'apush' 732 | apush(kind(x) == phrasetype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:732:3: note: in expansion of macro 'apush' 732 | apush(kind(x) == phrasetype ? True_val : False_val); | ^~~~~ atops.c: In function 'iisfault': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:741:3: note: in expansion of macro 'apush' 741 | apush(kind(x) == faulttype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:741:3: note: in expansion of macro 'apush' 741 | apush(kind(x) == faulttype ? True_val : False_val); | ^~~~~ atops.c: In function 'iisstring': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:748:3: note: in expansion of macro 'apush' 748 | apush(isstring(x) ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:748:3: note: in expansion of macro 'apush' 748 | apush(isstring(x) ? True_val : False_val); | ^~~~~ atops.c: In function 'inumeric': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:755:3: note: in expansion of macro 'apush' 755 | apush(numeric(kind(x)) && valence(x)==0 ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:755:3: note: in expansion of macro 'apush' 755 | apush(numeric(kind(x)) && valence(x)==0 ? True_val : False_val); | ^~~~~ atops.c: In function 'iallbools': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:762:3: note: in expansion of macro 'apush' 762 | apush(kind(x) == booltype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:762:3: note: in expansion of macro 'apush' 762 | apush(kind(x) == booltype ? True_val : False_val); | ^~~~~ atops.c: In function 'iallints': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:769:3: note: in expansion of macro 'apush' 769 | apush(kind(x) == inttype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:769:3: note: in expansion of macro 'apush' 769 | apush(kind(x) == inttype ? True_val : False_val); | ^~~~~ atops.c: In function 'iallreals': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:776:3: note: in expansion of macro 'apush' 776 | apush(kind(x) == realtype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:776:3: note: in expansion of macro 'apush' 776 | apush(kind(x) == realtype ? True_val : False_val); | ^~~~~ atops.c: In function 'iallchars': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:783:3: note: in expansion of macro 'apush' 783 | apush(kind(x) == chartype ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:783:3: note: in expansion of macro 'apush' 783 | apush(kind(x) == chartype ? True_val : False_val); | ^~~~~ atops.c: In function 'iallnumeric': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:792:3: note: in expansion of macro 'apush' 792 | apush(numeric(kind(x)) ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:792:3: note: in expansion of macro 'apush' 792 | apush(numeric(kind(x)) ? True_val : False_val); | ^~~~~ atops.c: In function 'itally': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:818:3: note: in expansion of macro 'apush' 818 | apush(createint(tally(x))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:818:3: note: in expansion of macro 'apush' 818 | apush(createint(tally(x))); | ^~~~~ atops.c: In function 'ilink': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:866:5: note: in expansion of macro 'apush' 866 | apush(x); /* to protect x */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:866:5: note: in expansion of macro 'apush' 866 | apush(x); /* to protect x */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:885:7: note: in expansion of macro 'apush' 885 | { apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:885:7: note: in expansion of macro 'apush' 885 | { apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:934:7: note: in expansion of macro 'apush' 934 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:934:7: note: in expansion of macro 'apush' 934 | apush(z); | ^~~~~ atops.c: In function 'igage': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:949:3: note: in expansion of macro 'apush' 949 | apush(gage(x)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:949:3: note: in expansion of macro 'apush' 949 | apush(gage(x)); | ^~~~~ atops.c: In function 'gage': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:982:9: note: in expansion of macro 'apush' 982 | { apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:982:9: note: in expansion of macro 'apush' 982 | { apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:990:3: note: in expansion of macro 'apush' 990 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:990:3: note: in expansion of macro 'apush' 990 | apush(x); | ^~~~~ atops.c: In function 'icart': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1099:3: note: in expansion of macro 'apush' 1099 | apush(top); /* will need this four times */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1099:3: note: in expansion of macro 'apush' 1099 | apush(top); /* will need this four times */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1100:3: note: in expansion of macro 'apush' 1100 | apush(top); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1100:3: note: in expansion of macro 'apush' 1100 | apush(top); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1101:3: note: in expansion of macro 'apush' 1101 | apush(top); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1101:3: note: in expansion of macro 'apush' 1101 | apush(top); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1144:5: note: in expansion of macro 'apush' 1144 | apush(result); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1144:5: note: in expansion of macro 'apush' 1144 | apush(result); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1150:5: note: in expansion of macro 'apush' 1150 | apush(result); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1150:5: note: in expansion of macro 'apush' 1150 | apush(result); | ^~~~~ atops.c: In function 'ivoid': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1166:3: note: in expansion of macro 'apush' 1166 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1166:3: note: in expansion of macro 'apush' 1166 | apush(Null); | ^~~~~ atops.c: In function 'itell': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1210:5: note: in expansion of macro 'apush' 1210 | apush(makefault("?shape")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1210:5: note: in expansion of macro 'apush' 1210 | apush(makefault("?shape")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1221:5: note: in expansion of macro 'apush' 1221 | apush(generateints(n)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1221:5: note: in expansion of macro 'apush' 1221 | apush(generateints(n)); | ^~~~~ atops.c: In function 'itake': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1309:5: note: in expansion of macro 'apush' 1309 | apush(makefault("?argument of take must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1309:5: note: in expansion of macro 'apush' 1309 | apush(makefault("?argument of take must be a pair")); | ^~~~~ atops.c: In function 'idrop': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1339:5: note: in expansion of macro 'apush' 1339 | apush(makefault("?argument of drop must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1339:5: note: in expansion of macro 'apush' 1339 | apush(makefault("?argument of drop must be a pair")); | ^~~~~ atops.c: In function 'takedrop': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1402:7: note: in expansion of macro 'apush' 1402 | apush(makefault("?left argument in take must be integers")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1402:7: note: in expansion of macro 'apush' 1402 | apush(makefault("?left argument in take must be integers")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1405:7: note: in expansion of macro 'apush' 1405 | apush(makefault("?left argument in drop must be integers")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1405:7: note: in expansion of macro 'apush' 1405 | apush(makefault("?left argument in drop must be integers")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1415:7: note: in expansion of macro 'apush' 1415 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1415:7: note: in expansion of macro 'apush' 1415 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1423:9: note: in expansion of macro 'apush' 1423 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1423:9: note: in expansion of macro 'apush' 1423 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1426:9: note: in expansion of macro 'apush' 1426 | apush(Null); /* other drops on a single is Null */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1426:9: note: in expansion of macro 'apush' 1426 | apush(Null); /* other drops on a single is Null */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1443:7: note: in expansion of macro 'apush' 1443 | apush(makefault("?valence error in take")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1443:7: note: in expansion of macro 'apush' 1443 | apush(makefault("?valence error in take")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1447:7: note: in expansion of macro 'apush' 1447 | apush(makefault("?valence error in drop")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1447:7: note: in expansion of macro 'apush' 1447 | apush(makefault("?valence error in drop")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1455:5: note: in expansion of macro 'apush' 1455 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1455:5: note: in expansion of macro 'apush' 1455 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1496:7: note: in expansion of macro 'apush' 1496 | apush(createint(length)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1496:7: note: in expansion of macro 'apush' 1496 | apush(createint(length)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1497:7: note: in expansion of macro 'apush' 1497 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1497:7: note: in expansion of macro 'apush' 1497 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1521:13: note: in expansion of macro 'apush' 1521 | apush(fetchasarray(y, 0)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1521:13: note: in expansion of macro 'apush' 1521 | apush(fetchasarray(y, 0)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1576:7: note: in expansion of macro 'apush' 1576 | apush(lengths); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1576:7: note: in expansion of macro 'apush' 1576 | apush(lengths); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1577:7: note: in expansion of macro 'apush' 1577 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1577:7: note: in expansion of macro 'apush' 1577 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1638:13: note: in expansion of macro 'apush' 1638 | apush(fetchasarray(y, 0)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1638:13: note: in expansion of macro 'apush' 1638 | apush(fetchasarray(y, 0)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1705:3: note: in expansion of macro 'apush' 1705 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1705:3: note: in expansion of macro 'apush' 1705 | apush(z); | ^~~~~ atops.c: In function 'icut': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1788:5: note: in expansion of macro 'apush' 1788 | apush(makefault("?argument of cut must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1788:5: note: in expansion of macro 'apush' 1788 | apush(makefault("?argument of cut must be a pair")); | ^~~~~ atops.c: In function 'icutall': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1821:5: note: in expansion of macro 'apush' 1821 | apush(makefault("?argument of cutall must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1821:5: note: in expansion of macro 'apush' 1821 | apush(makefault("?argument of cutall must be a pair")); | ^~~~~ atops.c: In function 'cutorcutall': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1844:9: note: in expansion of macro 'apush' 1844 | { apush(makefault("?first arg of cut is not boolean")); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1844:9: note: in expansion of macro 'apush' 1844 | { apush(makefault("?first arg of cut is not boolean")); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1846:7: note: in expansion of macro 'apush' 1846 | apush(makefault("?first arg of cutall is not boolean")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1846:7: note: in expansion of macro 'apush' 1846 | apush(makefault("?first arg of cutall is not boolean")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1855:11: note: in expansion of macro 'apush' 1855 | { apush(makefault("?first arg of cut is empty")); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1855:11: note: in expansion of macro 'apush' 1855 | { apush(makefault("?first arg of cut is empty")); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1857:11: note: in expansion of macro 'apush' 1857 | { apush(makefault("?first arg of cutall is empty")); } | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1857:11: note: in expansion of macro 'apush' 1857 | { apush(makefault("?first arg of cutall is empty")); } | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1872:5: note: in expansion of macro 'apush' 1872 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1872:5: note: in expansion of macro 'apush' 1872 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1909:3: note: in expansion of macro 'apush' 1909 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1909:3: note: in expansion of macro 'apush' 1909 | apush(z); | ^~~~~ atops.c: In function 'isublist': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1950:5: note: in expansion of macro 'apush' 1950 | apush(makefault("?argument of sublist must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1950:5: note: in expansion of macro 'apush' 1950 | apush(makefault("?argument of sublist must be a pair")); | ^~~~~ atops.c: In function 'sublist': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1976:5: note: in expansion of macro 'apush' 1976 | apush(makefault("?first arg of sublist not boolean")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1976:5: note: in expansion of macro 'apush' 1976 | apush(makefault("?first arg of sublist not boolean")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1987:7: note: in expansion of macro 'apush' 1987 | { apush(makefault("?first arg of sublist is empty")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1987:7: note: in expansion of macro 'apush' 1987 | { apush(makefault("?first arg of sublist is empty")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:1999:5: note: in expansion of macro 'apush' 1999 | { apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:1999:5: note: in expansion of macro 'apush' 1999 | { apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2022:5: note: in expansion of macro 'apush' 2022 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2022:5: note: in expansion of macro 'apush' 2022 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2033:5: note: in expansion of macro 'apush' 2033 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2033:5: note: in expansion of macro 'apush' 2033 | apush(Null); | ^~~~~ atops.c: In function 'isimple': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2053:5: note: in expansion of macro 'apush' 2053 | apush(True_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2053:5: note: in expansion of macro 'apush' 2053 | apush(True_val); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2056:5: note: in expansion of macro 'apush' 2056 | apush(False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2056:5: note: in expansion of macro 'apush' 2056 | apush(False_val); | ^~~~~ atops.c: In function 'pack': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2323:13: note: in expansion of macro 'apush' 2323 | apush(makefault("?conform")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2323:13: note: in expansion of macro 'apush' 2323 | apush(makefault("?conform")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2389:5: note: in expansion of macro 'apush' 2389 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2389:5: note: in expansion of macro 'apush' 2389 | apush(z); | ^~~~~ atops.c: In function 'iseek': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2431:5: note: in expansion of macro 'apush' 2431 | apush(makefault("?argument to seek must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2431:5: note: in expansion of macro 'apush' 2431 | apush(makefault("?argument to seek must be a pair")); | ^~~~~ atops.c: In function 'ifind': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2462:5: note: in expansion of macro 'apush' 2462 | apush(makefault("?argument to find must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2462:5: note: in expansion of macro 'apush' 2462 | apush(makefault("?argument to find must be a pair")); | ^~~~~ atops.c: In function 'iin': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2494:5: note: in expansion of macro 'apush' 2494 | apush(makefault("?argument to in must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2494:5: note: in expansion of macro 'apush' 2494 | apush(makefault("?argument to in must be a pair")); | ^~~~~ atops.c: In function 'ifindall': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2525:5: note: in expansion of macro 'apush' 2525 | apush(makefault("?argument to findall must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2525:5: note: in expansion of macro 'apush' 2525 | apush(makefault("?argument to findall must be a pair")); | ^~~~~ atops.c: In function 'nseek': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2646:5: note: in expansion of macro 'apush' 2646 | apush(x); /* to protect it for multiple calls of equal */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2646:5: note: in expansion of macro 'apush' 2646 | apush(x); /* to protect it for multiple calls of equal */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2653:3: note: in expansion of macro 'apush' 2653 | apush(createbool(res)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2653:3: note: in expansion of macro 'apush' 2653 | apush(createbool(res)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2656:7: note: in expansion of macro 'apush' 2656 | apush(createint(i - 1)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2656:7: note: in expansion of macro 'apush' 2656 | apush(createint(i - 1)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2659:7: note: in expansion of macro 'apush' 2659 | apush(ToAddress(i - 1, shpptr(y, v), v)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2659:7: note: in expansion of macro 'apush' 2659 | apush(ToAddress(i - 1, shpptr(y, v), v)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2665:7: note: in expansion of macro 'apush' 2665 | apush(createint(ty)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2665:7: note: in expansion of macro 'apush' 2665 | apush(createint(ty)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2669:7: note: in expansion of macro 'apush' 2669 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2669:7: note: in expansion of macro 'apush' 2669 | apush(y); | ^~~~~ atops.c: In function 'findall': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2691:7: note: in expansion of macro 'apush' 2691 | apush(Null); /* result is Null */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2691:7: note: in expansion of macro 'apush' 2691 | apush(Null); /* result is Null */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2735:3: note: in expansion of macro 'apush' 2735 | apush(x); /* protect x */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2735:3: note: in expansion of macro 'apush' 2735 | apush(x); /* protect x */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2762:3: note: in expansion of macro 'apush' 2762 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2762:3: note: in expansion of macro 'apush' 2762 | apush(z); | ^~~~~ atops.c: In function 'sfindallint': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2860:5: note: in expansion of macro 'apush' 2860 | apush(createbool(low <= high)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2860:5: note: in expansion of macro 'apush' 2860 | apush(createbool(low <= high)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2863:9: note: in expansion of macro 'apush' 2863 | apush(createint(low)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2863:9: note: in expansion of macro 'apush' 2863 | apush(createint(low)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2866:9: note: in expansion of macro 'apush' 2866 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2866:9: note: in expansion of macro 'apush' 2866 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2871:9: note: in expansion of macro 'apush' 2871 | apush(createint(ty)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2871:9: note: in expansion of macro 'apush' 2871 | apush(createint(ty)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2875:9: note: in expansion of macro 'apush' 2875 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2875:9: note: in expansion of macro 'apush' 2875 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2883:7: note: in expansion of macro 'apush' 2883 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2883:7: note: in expansion of macro 'apush' 2883 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2894:9: note: in expansion of macro 'apush' 2894 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2894:9: note: in expansion of macro 'apush' 2894 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2900:9: note: in expansion of macro 'apush' 2900 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2900:9: note: in expansion of macro 'apush' 2900 | apush(z); | ^~~~~ atops.c: In function 'sfindallreal': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2988:5: note: in expansion of macro 'apush' 2988 | apush(createbool(low <= high)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2988:5: note: in expansion of macro 'apush' 2988 | apush(createbool(low <= high)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2991:9: note: in expansion of macro 'apush' 2991 | apush(createint(low)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2991:9: note: in expansion of macro 'apush' 2991 | apush(createint(low)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2994:9: note: in expansion of macro 'apush' 2994 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2994:9: note: in expansion of macro 'apush' 2994 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:2999:9: note: in expansion of macro 'apush' 2999 | apush(createint(ty)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:2999:9: note: in expansion of macro 'apush' 2999 | apush(createint(ty)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3003:9: note: in expansion of macro 'apush' 3003 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3003:9: note: in expansion of macro 'apush' 3003 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3011:7: note: in expansion of macro 'apush' 3011 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3011:7: note: in expansion of macro 'apush' 3011 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3022:9: note: in expansion of macro 'apush' 3022 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3022:9: note: in expansion of macro 'apush' 3022 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3028:9: note: in expansion of macro 'apush' 3028 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3028:9: note: in expansion of macro 'apush' 3028 | apush(z); | ^~~~~ atops.c: In function 'sfindallatype': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3050:3: note: in expansion of macro 'apush' 3050 | apush(x); /* protect x in uses of equal and up as target */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3050:3: note: in expansion of macro 'apush' 3050 | apush(x); /* protect x in uses of equal and up as target */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3119:5: note: in expansion of macro 'apush' 3119 | apush(createbool(low <= high)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3119:5: note: in expansion of macro 'apush' 3119 | apush(createbool(low <= high)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3122:9: note: in expansion of macro 'apush' 3122 | apush(createint(low)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3122:9: note: in expansion of macro 'apush' 3122 | apush(createint(low)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3125:9: note: in expansion of macro 'apush' 3125 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3125:9: note: in expansion of macro 'apush' 3125 | apush(ToAddress(low, shpptr(y, v), v)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3130:9: note: in expansion of macro 'apush' 3130 | apush(createint(ty)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3130:9: note: in expansion of macro 'apush' 3130 | apush(createint(ty)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3134:9: note: in expansion of macro 'apush' 3134 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3134:9: note: in expansion of macro 'apush' 3134 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3142:7: note: in expansion of macro 'apush' 3142 | apush(Null); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3142:7: note: in expansion of macro 'apush' 3142 | apush(Null); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3153:9: note: in expansion of macro 'apush' 3153 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3153:9: note: in expansion of macro 'apush' 3153 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3159:9: note: in expansion of macro 'apush' 3159 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3159:9: note: in expansion of macro 'apush' 3159 | apush(z); | ^~~~~ atops.c: In function 'cull': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3231:3: note: in expansion of macro 'apush' 3231 | apush(a); /* list it so indices are simpler */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3231:3: note: in expansion of macro 'apush' 3231 | apush(a); /* list it so indices are simpler */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3286:5: note: in expansion of macro 'apush' 3286 | apush(pattern); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3286:5: note: in expansion of macro 'apush' 3286 | apush(pattern); | ^~~~~ atops.c: In function 'scull': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3350:5: note: in expansion of macro 'apush' 3350 | apush(pattern); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3350:5: note: in expansion of macro 'apush' 3350 | apush(pattern); | ^~~~~ atops.c: In function 'iexcept': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3478:5: note: in expansion of macro 'apush' 3478 | apush(makefault("?argument of except must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3478:5: note: in expansion of macro 'apush' 3478 | apush(makefault("?argument of except must be a pair")); | ^~~~~ atops.c: In function 'except': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3559:3: note: in expansion of macro 'apush' 3559 | apush(a); /* list it so indices are simpler and there are | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3559:3: note: in expansion of macro 'apush' 3559 | apush(a); /* list it so indices are simpler and there are | ^~~~~ atops.c: In function 'sexcept': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3734:3: note: in expansion of macro 'apush' 3734 | apush(a); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3734:3: note: in expansion of macro 'apush' 3734 | apush(a); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3741:5: note: in expansion of macro 'apush' 3741 | apush(a); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3741:5: note: in expansion of macro 'apush' 3741 | apush(a); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3859:11: note: in expansion of macro 'apush' 3859 | apush(itemb); /* to protect it in up */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3859:11: note: in expansion of macro 'apush' 3859 | apush(itemb); /* to protect it in up */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3905:3: note: in expansion of macro 'apush' 3905 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3905:3: note: in expansion of macro 'apush' 3905 | apush(z); | ^~~~~ atops.c: In function 'oldexcept': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3927:5: note: in expansion of macro 'apush' 3927 | apush(arr); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3927:5: note: in expansion of macro 'apush' 3927 | apush(arr); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3933:5: note: in expansion of macro 'apush' 3933 | apush(x); /* needed to avoid equal removing x when it is | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3933:5: note: in expansion of macro 'apush' 3933 | apush(x); /* needed to avoid equal removing x when it is | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3939:5: note: in expansion of macro 'apush' 3939 | apush(arr); /* needed to avoid equal removing arr when it is | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3939:5: note: in expansion of macro 'apush' 3939 | apush(arr); /* needed to avoid equal removing arr when it is | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3949:5: note: in expansion of macro 'apush' 3949 | apush(it); /* protect during equal */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3949:5: note: in expansion of macro 'apush' 3949 | apush(it); /* protect during equal */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3983:5: note: in expansion of macro 'apush' 3983 | apush(nnz); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3983:5: note: in expansion of macro 'apush' 3983 | apush(nnz); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:3987:5: note: in expansion of macro 'apush' 3987 | apush(nz); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:3987:5: note: in expansion of macro 'apush' 3987 | apush(nz); | ^~~~~ atops.c: In function 'iatomic': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4004:5: note: in expansion of macro 'apush' 4004 | apush(True_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4004:5: note: in expansion of macro 'apush' 4004 | apush(True_val); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4007:5: note: in expansion of macro 'apush' 4007 | apush(False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4007:5: note: in expansion of macro 'apush' 4007 | apush(False_val); | ^~~~~ atops.c: In function 'ivalence': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4025:3: note: in expansion of macro 'apush' 4025 | apush(createint((nialint) valence(z))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4025:3: note: in expansion of macro 'apush' 4025 | apush(createint((nialint) valence(z))); | ^~~~~ atops.c: In function 'b_raise': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4055:7: note: in expansion of macro 'apush' 4055 | apush(nial_raise(y, n)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4055:7: note: in expansion of macro 'apush' 4055 | apush(nial_raise(y, n)); | ^~~~~ atops.c: In function 'iraise': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4076:5: note: in expansion of macro 'apush' 4076 | apush(makefault("?argument of raise must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4076:5: note: in expansion of macro 'apush' 4076 | apush(makefault("?argument of raise must be a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4088:9: note: in expansion of macro 'apush' 4088 | apush(nial_raise(y, n)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4088:9: note: in expansion of macro 'apush' 4088 | apush(nial_raise(y, n)); | ^~~~~ atops.c: In function 'nial_raise': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4127:9: note: in expansion of macro 'apush' 4127 | { apush(x); /* to protect x during each */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4127:9: note: in expansion of macro 'apush' 4127 | { apush(x); /* to protect x during each */ | ^~~~~ atops.c: In function 'ifuse': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4227:5: note: in expansion of macro 'apush' 4227 | apush(makefault("?argument of fuse must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4227:5: note: in expansion of macro 'apush' 4227 | apush(makefault("?argument of fuse must be a pair")); | ^~~~~ atops.c: In function 'fuse': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4277:3: note: in expansion of macro 'apush' 4277 | apush(b); /* to protect b in ishape */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4277:3: note: in expansion of macro 'apush' 4277 | apush(b); /* to protect b in ishape */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4278:3: note: in expansion of macro 'apush' 4278 | apush(b); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4278:3: note: in expansion of macro 'apush' 4278 | apush(b); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4287:7: note: in expansion of macro 'apush' 4287 | apush(b); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4287:7: note: in expansion of macro 'apush' 4287 | apush(b); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4296:7: note: in expansion of macro 'apush' 4296 | apush(b); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4296:7: note: in expansion of macro 'apush' 4296 | apush(b); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4361:5: note: in expansion of macro 'apush' 4361 | apush(check); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4361:5: note: in expansion of macro 'apush' 4361 | apush(check); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4377:7: note: in expansion of macro 'apush' 4377 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4377:7: note: in expansion of macro 'apush' 4377 | apush(z); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4466:7: note: in expansion of macro 'apush' 4466 | apush(result); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4466:7: note: in expansion of macro 'apush' 4466 | apush(result); | ^~~~~ atops.c: In function 'itranspose': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4495:5: note: in expansion of macro 'apush' 4495 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4495:5: note: in expansion of macro 'apush' 4495 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4608:5: note: in expansion of macro 'apush' 4608 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4608:5: note: in expansion of macro 'apush' 4608 | apush(z); | ^~~~~ atops.c: In function 'ireverse': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4628:5: note: in expansion of macro 'apush' 4628 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4628:5: note: in expansion of macro 'apush' 4628 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4637:5: note: in expansion of macro 'apush' 4637 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4637:5: note: in expansion of macro 'apush' 4637 | apush(z); | ^~~~~ atops.c: In function 'iempty': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4652:5: note: in expansion of macro 'apush' 4652 | apush(True_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4652:5: note: in expansion of macro 'apush' 4652 | apush(True_val); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4655:5: note: in expansion of macro 'apush' 4655 | apush(False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4655:5: note: in expansion of macro 'apush' 4655 | apush(False_val); | ^~~~~ atops.c: In function 'imix': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4681:3: note: in expansion of macro 'apush' 4681 | apush(top); /* duplicate top so we can get its shape */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4681:3: note: in expansion of macro 'apush' 4681 | apush(top); /* duplicate top so we can get its shape */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4688:5: note: in expansion of macro 'apush' 4688 | apush(shp); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4688:5: note: in expansion of macro 'apush' 4688 | apush(shp); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4689:5: note: in expansion of macro 'apush' 4689 | apush(Zero); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4689:5: note: in expansion of macro 'apush' 4689 | apush(Zero); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4691:5: note: in expansion of macro 'apush' 4691 | apush(Null); /* reshape Null since A has no items */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4691:5: note: in expansion of macro 'apush' 4691 | apush(Null); /* reshape Null since A has no items */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ atops.c:4711:3: note: in expansion of macro 'apush' 4711 | apush(fetchasarray(top,0)); /* first A */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ atops.c:4711:3: note: in expansion of macro 'apush' 4711 | apush(fetchasarray(top,0)); /* first A */ | ^~~~~ gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o basics.o basics.c gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o blders.o blders.c In file included from blders.c:32: blders.c: In function 'b_opform': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:140:3: note: in expansion of macro 'apush' 140 | apush(createint((nialint) t_opform)); | ^~~~~ In file included from blders.c:33: lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:140:3: note: in expansion of macro 'apush' 140 | apush(createint((nialint) t_opform)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:141:3: note: in expansion of macro 'apush' 141 | apush(sym); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:141:3: note: in expansion of macro 'apush' 141 | apush(sym); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:142:3: note: in expansion of macro 'apush' 142 | apush(cenv); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:142:3: note: in expansion of macro 'apush' 142 | apush(cenv); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:143:3: note: in expansion of macro 'apush' 143 | apush(createint((nialint) nvars)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:143:3: note: in expansion of macro 'apush' 143 | apush(createint((nialint) nvars)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:144:3: note: in expansion of macro 'apush' 144 | apush(arglist); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:144:3: note: in expansion of macro 'apush' 144 | apush(arglist); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:145:3: note: in expansion of macro 'apush' 145 | apush(body); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:145:3: note: in expansion of macro 'apush' 145 | apush(body); | ^~~~~ blders.c: In function 'b_blockbody': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:153:3: note: in expansion of macro 'apush' 153 | apush(createint((nialint) t_blockbody)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:153:3: note: in expansion of macro 'apush' 153 | apush(createint((nialint) t_blockbody)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:154:3: note: in expansion of macro 'apush' 154 | apush(locallist); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:154:3: note: in expansion of macro 'apush' 154 | apush(locallist); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:155:3: note: in expansion of macro 'apush' 155 | apush(nonlocallist); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:155:3: note: in expansion of macro 'apush' 155 | apush(nonlocallist); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:156:3: note: in expansion of macro 'apush' 156 | apush(defs); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:156:3: note: in expansion of macro 'apush' 156 | apush(defs); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:157:3: note: in expansion of macro 'apush' 157 | apush(body); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:157:3: note: in expansion of macro 'apush' 157 | apush(body); | ^~~~~ blders.c: In function 'b_trform': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:165:3: note: in expansion of macro 'apush' 165 | apush(createint((nialint) t_trform)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:165:3: note: in expansion of macro 'apush' 165 | apush(createint((nialint) t_trform)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:166:3: note: in expansion of macro 'apush' 166 | apush(sym); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:166:3: note: in expansion of macro 'apush' 166 | apush(sym); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:167:3: note: in expansion of macro 'apush' 167 | apush(env); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:167:3: note: in expansion of macro 'apush' 167 | apush(env); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:168:3: note: in expansion of macro 'apush' 168 | apush(opargs); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:168:3: note: in expansion of macro 'apush' 168 | apush(opargs); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:169:3: note: in expansion of macro 'apush' 169 | apush(trbody); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:169:3: note: in expansion of macro 'apush' 169 | apush(trbody); | ^~~~~ blders.c: In function 'b_caseexpr': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:187:3: note: in expansion of macro 'apush' 187 | apush(createint(t_caseexpr)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:187:3: note: in expansion of macro 'apush' 187 | apush(createint(t_caseexpr)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:188:3: note: in expansion of macro 'apush' 188 | apush(ctest); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:188:3: note: in expansion of macro 'apush' 188 | apush(ctest); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:189:3: note: in expansion of macro 'apush' 189 | apush(selectvals); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:189:3: note: in expansion of macro 'apush' 189 | apush(selectvals); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:190:3: note: in expansion of macro 'apush' 190 | apush(selectexprs); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:190:3: note: in expansion of macro 'apush' 190 | apush(selectexprs); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:191:3: note: in expansion of macro 'apush' 191 | apush(exprseqs); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:191:3: note: in expansion of macro 'apush' 191 | apush(exprseqs); | ^~~~~ blders.c: In function 'b_block': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:200:3: note: in expansion of macro 'apush' 200 | apush(createint(t_block)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:200:3: note: in expansion of macro 'apush' 200 | apush(createint(t_block)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:201:3: note: in expansion of macro 'apush' 201 | apush(sym); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:201:3: note: in expansion of macro 'apush' 201 | apush(sym); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:202:3: note: in expansion of macro 'apush' 202 | apush(cenv); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:202:3: note: in expansion of macro 'apush' 202 | apush(cenv); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:203:3: note: in expansion of macro 'apush' 203 | apush(createint(nvars)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:203:3: note: in expansion of macro 'apush' 203 | apush(createint(nvars)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ blders.c:204:3: note: in expansion of macro 'apush' 204 | apush(body); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ blders.c:204:3: note: in expansion of macro 'apush' 204 | apush(body); | ^~~~~ gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o compare.o compare.c In file included from compare.c:35: compare.c: In function 'b_max': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:102:11: note: in expansion of macro 'apush' 102 | apush(x); | ^~~~~ In file included from compare.c:34: lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:102:11: note: in expansion of macro 'apush' 102 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:103:11: note: in expansion of macro 'apush' 103 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:103:11: note: in expansion of macro 'apush' 103 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:232:7: note: in expansion of macro 'apush' 232 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:232:7: note: in expansion of macro 'apush' 232 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:233:7: note: in expansion of macro 'apush' 233 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:233:7: note: in expansion of macro 'apush' 233 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:250:3: note: in expansion of macro 'apush' 250 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:250:3: note: in expansion of macro 'apush' 250 | apush(z); | ^~~~~ compare.c: In function 'imax': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:267:9: note: in expansion of macro 'apush' 267 | apush(createbool(orbools(x, tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:267:9: note: in expansion of macro 'apush' 267 | apush(createbool(orbools(x, tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:270:9: note: in expansion of macro 'apush' 270 | apush(createint(maxints(pfirstint(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:270:9: note: in expansion of macro 'apush' 270 | apush(createint(maxints(pfirstint(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:273:9: note: in expansion of macro 'apush' 273 | apush(createreal(maxreals(pfirstreal(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:273:9: note: in expansion of macro 'apush' 273 | apush(createreal(maxreals(pfirstreal(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:276:9: note: in expansion of macro 'apush' 276 | apush(createchar(maxchars(pfirstchar(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:276:9: note: in expansion of macro 'apush' 276 | apush(createchar(maxchars(pfirstchar(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:279:9: note: in expansion of macro 'apush' 279 | apush(Zenith); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:279:9: note: in expansion of macro 'apush' 279 | apush(Zenith); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:282:9: note: in expansion of macro 'apush' 282 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:282:9: note: in expansion of macro 'apush' 282 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:286:11: note: in expansion of macro 'apush' 286 | apush(createatom(faulttype, "?O")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:286:11: note: in expansion of macro 'apush' 286 | apush(createatom(faulttype, "?O")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:292:11: note: in expansion of macro 'apush' 292 | apush(maxitem); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:292:11: note: in expansion of macro 'apush' 292 | apush(maxitem); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:294:13: note: in expansion of macro 'apush' 294 | { apush(fetch_array(x, i)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:294:13: note: in expansion of macro 'apush' 294 | { apush(fetch_array(x, i)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:299:11: note: in expansion of macro 'apush' 299 | apush(fetch_array(x, 0)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:299:11: note: in expansion of macro 'apush' 299 | apush(fetch_array(x, 0)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:300:11: note: in expansion of macro 'apush' 300 | apush(fetch_array(x, 1)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:300:11: note: in expansion of macro 'apush' 300 | apush(fetch_array(x, 1)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:304:11: note: in expansion of macro 'apush' 304 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:304:11: note: in expansion of macro 'apush' 304 | apush(x); | ^~~~~ compare.c: In function 'b_min': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:467:11: note: in expansion of macro 'apush' 467 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:467:11: note: in expansion of macro 'apush' 467 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:468:11: note: in expansion of macro 'apush' 468 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:468:11: note: in expansion of macro 'apush' 468 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:599:7: note: in expansion of macro 'apush' 599 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:599:7: note: in expansion of macro 'apush' 599 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:600:7: note: in expansion of macro 'apush' 600 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:600:7: note: in expansion of macro 'apush' 600 | apush(y); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:617:3: note: in expansion of macro 'apush' 617 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:617:3: note: in expansion of macro 'apush' 617 | apush(z); | ^~~~~ compare.c: In function 'imin': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:634:9: note: in expansion of macro 'apush' 634 | apush(createbool(andbools(x, tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:634:9: note: in expansion of macro 'apush' 634 | apush(createbool(andbools(x, tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:637:9: note: in expansion of macro 'apush' 637 | apush(createint(minints(pfirstint(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:637:9: note: in expansion of macro 'apush' 637 | apush(createint(minints(pfirstint(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:640:9: note: in expansion of macro 'apush' 640 | apush(createreal(minreals(pfirstreal(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:640:9: note: in expansion of macro 'apush' 640 | apush(createreal(minreals(pfirstreal(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:643:9: note: in expansion of macro 'apush' 643 | apush(createchar(minchars(pfirstchar(x), tx))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:643:9: note: in expansion of macro 'apush' 643 | apush(createchar(minchars(pfirstchar(x), tx))); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:646:9: note: in expansion of macro 'apush' 646 | apush(Nadir); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:646:9: note: in expansion of macro 'apush' 646 | apush(Nadir); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:649:9: note: in expansion of macro 'apush' 649 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:649:9: note: in expansion of macro 'apush' 649 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:653:11: note: in expansion of macro 'apush' 653 | apush(createatom(faulttype, "?I")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:653:11: note: in expansion of macro 'apush' 653 | apush(createatom(faulttype, "?I")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:659:11: note: in expansion of macro 'apush' 659 | apush(minitem); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:659:11: note: in expansion of macro 'apush' 659 | apush(minitem); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:661:13: note: in expansion of macro 'apush' 661 | { apush(fetch_array(x, i)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:661:13: note: in expansion of macro 'apush' 661 | { apush(fetch_array(x, i)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:666:11: note: in expansion of macro 'apush' 666 | apush(fetch_array(x, 0)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:666:11: note: in expansion of macro 'apush' 666 | apush(fetch_array(x, 0)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:667:11: note: in expansion of macro 'apush' 667 | apush(fetch_array(x, 1)); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:667:11: note: in expansion of macro 'apush' 667 | apush(fetch_array(x, 1)); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:671:11: note: in expansion of macro 'apush' 671 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:671:11: note: in expansion of macro 'apush' 671 | apush(x); | ^~~~~ compare.c: In function 'b_lte': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:909:3: note: in expansion of macro 'apush' 909 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:909:3: note: in expansion of macro 'apush' 909 | apush(z); | ^~~~~ compare.c: In function 'ilte': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:925:5: note: in expansion of macro 'apush' 925 | apush(makefault("?<= expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:925:5: note: in expansion of macro 'apush' 925 | apush(makefault("?<= expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:932:5: note: in expansion of macro 'apush' 932 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:932:5: note: in expansion of macro 'apush' 932 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:933:5: note: in expansion of macro 'apush' 933 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:933:5: note: in expansion of macro 'apush' 933 | apush(y); | ^~~~~ compare.c: In function 'b_lt': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1333:3: note: in expansion of macro 'apush' 1333 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1333:3: note: in expansion of macro 'apush' 1333 | apush(z); | ^~~~~ compare.c: In function 'ilt': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1347:5: note: in expansion of macro 'apush' 1347 | apush(makefault("?< expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1347:5: note: in expansion of macro 'apush' 1347 | apush(makefault("?< expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1354:5: note: in expansion of macro 'apush' 1354 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1354:5: note: in expansion of macro 'apush' 1354 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1355:5: note: in expansion of macro 'apush' 1355 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1355:5: note: in expansion of macro 'apush' 1355 | apush(y); | ^~~~~ compare.c: In function 'mateormatch': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1458:3: note: in expansion of macro 'apush' 1458 | apush(z); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1458:3: note: in expansion of macro 'apush' 1458 | apush(z); | ^~~~~ compare.c: In function 'imate': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1472:5: note: in expansion of macro 'apush' 1472 | apush(makefault("?mate expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1472:5: note: in expansion of macro 'apush' 1472 | apush(makefault("?mate expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1479:5: note: in expansion of macro 'apush' 1479 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1479:5: note: in expansion of macro 'apush' 1479 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1480:5: note: in expansion of macro 'apush' 1480 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1480:5: note: in expansion of macro 'apush' 1480 | apush(y); | ^~~~~ compare.c: In function 'imatch': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1495:5: note: in expansion of macro 'apush' 1495 | apush(makefault("?match expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1495:5: note: in expansion of macro 'apush' 1495 | apush(makefault("?match expects a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1502:5: note: in expansion of macro 'apush' 1502 | apush(x); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1502:5: note: in expansion of macro 'apush' 1502 | apush(x); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1503:5: note: in expansion of macro 'apush' 1503 | apush(y); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1503:5: note: in expansion of macro 'apush' 1503 | apush(y); | ^~~~~ compare.c: In function 'igte': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1526:5: note: in expansion of macro 'apush' 1526 | apush(makefault("?>= expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1526:5: note: in expansion of macro 'apush' 1526 | apush(makefault("?>= expects a pair")); | ^~~~~ compare.c: In function 'igt': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1550:5: note: in expansion of macro 'apush' 1550 | apush(makefault("?> expects a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1550:5: note: in expansion of macro 'apush' 1550 | apush(makefault("?> expects a pair")); | ^~~~~ compare.c: In function 'iequal': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1575:5: note: in expansion of macro 'apush' 1575 | apush(True_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1575:5: note: in expansion of macro 'apush' 1575 | apush(True_val); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1583:5: note: in expansion of macro 'apush' 1583 | apush(x); /* to preserve x across multiple calls of equal */ | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1583:5: note: in expansion of macro 'apush' 1583 | apush(x); /* to preserve x across multiple calls of equal */ | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1587:5: note: in expansion of macro 'apush' 1587 | apush(result ? True_val : False_val); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1587:5: note: in expansion of macro 'apush' 1587 | apush(result ? True_val : False_val); | ^~~~~ compare.c: In function 'b_up': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1722:3: note: in expansion of macro 'apush' 1722 | apush(createbool(up(x, y))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1722:3: note: in expansion of macro 'apush' 1722 | apush(createbool(up(x, y))); | ^~~~~ compare.c: In function 'iup': absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1737:5: note: in expansion of macro 'apush' 1737 | apush(makefault("?argument of up must be a pair")); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1737:5: note: in expansion of macro 'apush' 1737 | apush(makefault("?argument of up must be a pair")); | ^~~~~ absmach.h:319:3: warning: this 'if' clause does not guard... [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wmisleading-indentation-Wmisleading-indentation8;;] 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~ compare.c:1741:5: note: in expansion of macro 'apush' 1741 | apush(createbool(up(x, y))); | ^~~~~ lib_main.h:241:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if' 241 | #define stkarea G1.g_stkarea | ^~ absmach.h:319:42: note: in expansion of macro 'stkarea' 319 | if (++topstack == stklim) growstack(); stkarea[topstack] = _y_;\ | ^~~~~~~ compare.c:1741:5: note: in expansion of macro 'apush' 1741 | apush(createbool(up(x, y))); | ^~~~~ gcc -g -DLINUX -DUNIXSYS -O2 -Wall -c -o coreif.o coreif.c coreif.c: In function 'NC_UpdateWindowSettings': coreif.c:507:52: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 507 | NC_SetWindowSetting(WindowSettings, NC_LOG_NAME, (int) logfnm); | ^ coreif.c:508:50: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 508 | NC_SetWindowSetting(WindowSettings, NC_FORMAT, (int) getformat()); | ^ coreif.c:509:50: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 509 | NC_SetWindowSetting(WindowSettings, NC_PROMPT, (int) prompt); | ^ coreif.c: In function 'NC_SetSessionSetting': coreif.c:684:55: error: assignment to 'int' from 'long int *' makes integer from pointer without a cast [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-conversion-Wint-conversion8;;] 684 | SessionSettingsTable[ioSettings - 1]->ws_size = inValue; | ^ coreif.c:688:61: error: assignment to 'int' from 'long int *' makes integer from pointer without a cast [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-conversion-Wint-conversion8;;] 688 | SessionSettingsTable[ioSettings - 1]->sdebugging_on = inValue; | ^ coreif.c:691:59: error: assignment to 'int' from 'long int *' makes integer from pointer without a cast [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-conversion-Wint-conversion8;;] 691 | SessionSettingsTable[ioSettings - 1]->form_switch = inValue; | ^ coreif.c:717:54: error: assignment to 'int' from 'long int *' makes integer from pointer without a cast [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-conversion-Wint-conversion8;;] 717 | SessionSettingsTable[ioSettings - 1]->squiet = inValue; | ^ coreif.c:721:58: error: assignment to 'int' from 'long int *' makes integer from pointer without a cast [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-conversion-Wint-conversion8;;] 721 | SessionSettingsTable[ioSettings - 1]->sexpansion = inValue; | ^ coreif.c: In function 'NC_GetSessionSetting': coreif.c:795:20: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 795 | *inValue = (int) SessionSettingsTable[ioSettings - 1]->defs_name; | ^ coreif.c:807:20: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 807 | *inValue = (int) SessionSettingsTable[ioSettings - 1]->ws_name; | ^ coreif.c: In function 'NC_SetWindowSetting': coreif.c:976:24: warning: cast to pointer from integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-to-pointer-cast-Wint-to-pointer-cast8;;] 976 | len = strlen((char *) inValue); | ^ coreif.c:982:66: warning: cast to pointer from integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-to-pointer-cast-Wint-to-pointer-cast8;;] 982 | WindowSettingsTable[ioSettings - 1]->log_name = strdup((char *) inValue); | ^ coreif.c:994:24: warning: cast to pointer from integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-to-pointer-cast-Wint-to-pointer-cast8;;] 994 | len = strlen((char *) inValue); | ^ coreif.c:1000:64: warning: cast to pointer from integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-to-pointer-cast-Wint-to-pointer-cast8;;] 1000 | WindowSettingsTable[ioSettings - 1]->format = strdup((char *) inValue); | ^ coreif.c:1014:65: warning: cast to pointer from integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wint-to-pointer-cast-Wint-to-pointer-cast8;;] 1014 | WindowSettingsTable[ioSettings - 1]->wprompt = strdup((char *) inValue); | ^ coreif.c: In function 'NC_GetWindowSetting': coreif.c:1108:21: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 1108 | *outValue = (int) WindowSettingsTable[ioSettings - 1]->log_name; | ^ coreif.c:1111:21: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 1111 | *outValue = (int) WindowSettingsTable[ioSettings - 1]->wprompt; | ^ coreif.c:1114:21: warning: cast from pointer to integer of different size [8;;https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Warning-Options.html#index-Wno-pointer-to-int-cast-Wpointer-to-int-cast8;;] 1114 | *outValue = (int) WindowSettingsTable[ioSettings - 1]->format; | ^ make: *** [: coreif.o] Error 1