what size is argc

genuine question please dont laugh at me

i would presume its either uint8 or something ridiculous like uint32/64 depending on architecture

but i dont actually know which lol

@coolbean um its an into usually but I have no idea what it is in like the Linux ABI

@yakmacker an into?

@yakmacker oh, int

@yakmacker yea but what type!

@coolbean *an int

@yakmacker too late i already got confused

@coolbean its a int because bell labs are a flock of useless chuds

@coolbean the type is int yeah
which is usually 32 bits in most C abis

@fiore what size fiore

what size of int

@fiore emilia said 32 usually so ill go with that. its a w instead of an x (i hate forth types with a passion)

@coolbean sizeof(int) , which depends on the target . but its 32bit if we are being real

@coolbean im pretty sure the standard explicitly does not say what the size of int is . but idk maybe we could ask @navi

@fiore @coolbean int is guaranteed to be at least 16 bit in the standard

@fiore @coolbean (oh i was already typing a reply)

first, argc itself purely is defined by the abi, e.g. for the x86_64 sysv abi¹ (which linux uses), the argument count is defined as "an eightbyte", which is more than an int in x86_64 (4 bytes)

but c does require main to be `int argc, char *argv[]`, so, c spec time, does int have a size? yes... kinda², the standard says that UINT_WIDTH, the width for an object of type unsigned int, is 16 bits or more

so your minimum, is 2 bytes, though in most platforms, it's 4 bytes, and "natively" outside c in x86_64 sysv specifically, it's actually 8 bytes, because it's just the word size of the processor -- your libc then implements _start, parses the aux data in the stack, and calls your main function passing in the value as an `int`

not that it matters much, tbh, even with the lowest range here, 2 byte int, that's still 32767 arguments, you're gonna hit posix's ARG_MAX wayy before you hit that limit

1: https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf -- figure 3.9, initial process stack
2: https://open-std.org/JTC1/SC22/WG14/www/docs/n3220.pdf -- 5.2.5.3.2 - Characteristics of integer types <limits.h>

@navi @coolbean @fiore ooh i had no idea about the sysv x86_64 abi actually making it an int64, brb passing 18 quintillion params to my program

@emiliamicrosystems @navi @coolbean posix knocks on your door and kills you

@fiore @coolbean @navi the effects of murder are not specified by posix

@emiliamicrosystems @coolbean @navi they need a test case first , dont push them

@emiliamicrosystems @coolbean @fiore
ARG_MAX is 2megs on linux, meanwhile the pointers alone, assuming they point to empty strings, would be 9 bytes each (8 for the pointer, 1 for the null byte)

meaning you have at max 233k empty string arguments before the kernel just straight up says "no"

@emiliamicrosystems @coolbean @fiore @navi the google solution

@fiore @coolbean @navi omg door is that a sun microsystems® spring® reference

@navi @fiore im just trying to avoid causing a memory bug while writing c-interop code in forth so i do, in fact, need to know the actual size so i dont read 8 bytes when its actually just 4 for instance

@navi @coolbean @fiore another example of linux Hating Fun..

@coolbean @navi i think u need to use sizeof for that

@navi @fiore or i read 4 but depending on if its a big or little endian system that reads either the upper or lower bytes of an int64

@coolbean @fiore either keep a list of sizes per platform, or better imo, during build time build a simple c program that just returns sizeof(int)

@coolbean @fiore actually no this is a bad idea it makes cross compilation hell

hm, what does meson and autotools do, lemme look it up

@navi @coolbean yea this

@navi @coolbean oh damn …

@navi @fiore i love how me kind of losing it about "what size is argc even" has, in retrospect, not made me look like an idiot cause its actually rather troubling

@navi @coolbean @fiore meson would take it from the machine file but i think it can also build a program (assuming it can run executables natively or via wrapper)

@coolbean @fiore well size of argc is int, size of int depends on the system abi

the problem here is getting the size of int from not-a-c-compiler tbh

though, how does your interop works, is it calling forth from c, or calling c from forth, or smth else?

@navi @fiore calling c from forth and also compiling callbacks back in c. in this specific case im running a c function that takes argc and argv pointers that i have to pass along from forth. i can in fact add my own function that just gives me sizeof(int) and i suspect ill leave it at that until someone comes up with a better solution

@coolbean @fiore if the function takes argc and argv, then you can just define the argc of that function to a known sized type, like int32_t or int64_t or whatever word size forth has, and let the compiler do the conversion

or, if it's that dynamic, yeah, take sizeof(int) as an argument somewhere

@navi @fiore that did just remind me that forth cells are also just ints

im killing myself

@navi @fiore well. 64bit on 64bit platforms

@coolbean @fiore oh awesome, i love when the solution turns out to be "do nothing" :3

@coolbean @fiore oh, then it's native word size, not ints, :blep: well conversion will be needed then

@navi @coolbean @fiore sizeof is available in preprocessor conditions right? you could at build time run cpp on a file with
#if sizeof (int) == 2
2
#elif sizeof (int) == 4
4
#elif sizeof (int) == 8
8
#else
#error what
#endif

and that works with cross compiling

@emiliamicrosystems @coolbean @fiore

i don't think you can use sizeof in preprocesor directives, the preprocessor has no awareness of types at all (which is why sizeof and _Generic and typeof and such are keywords, not preprocessor macros)

foo.c:1:11: error: missing binary operator before token ‘(’
1 | #if sizeof(int) == 4

@navi @emiliamicrosystems @coolbean @fiore Yeah only way with asking C is probably to use static_assert (C11+) and a shell loop, which is awfully autotools.

@coolbean @fiore @navi usually intptr or smth lime that so the compiler doesn't yell at you and to make sure it's register sized

@lanodan @coolbean @fiore @navi you don't need static assert (you can use typedef foo char[cnd ? 1 : -1] or switch(0){ case 0: case cnd: }) but yeah

@emiliamicrosystems @coolbean @fiore @navi Yeah, somewhat less readable but can be used as polyfill.

@navi @coolbean @fiore but you can just hardcode/assume 32-bit for int unless u wanna support 16-bit platforms or some cursed dead ILP64 unix

@navi @coolbean @fiore on sysV anything other than a float can go in the same register without issues, as I found with a hackjob repl that I made without knowing how to parse C code

miss @emiliamicrosystems , mx @coolbean , miss @fiore , miss @navi : think the correct way to do this is with the __INT_WIDTH__ macro instead

@minekpo1 @emiliamicrosystems @fiore @navi CORRECT

@coolbean couldn't you just write a program to print sizeof(argc)? or is that not how it works.

@minekpo1 @coolbean @fiore @navi where is that supposed to be defined

miss @emiliamicrosystems , mx @coolbean , miss @fiore , miss @navi : cpp -dD lists it as a builtin

@minekpo1 @coolbean @fiore @navi could be a nonstandard extension

@emiliamicrosystems @coolbean @fiore @minekpo1

seems like it is, but actually, you can also `#include <limits.h>` and use UINT_WIDTH which is standard

@minekpo1 @emiliamicrosystems @coolbean @navi oh right .

@navi @coolbean @fiore @minekpo1 it is standard in C23, which is not available everywhere and not required by POSIX

@minekpo1 @coolbean @fiore @navi there's INT_WIDTH without the underscores but thats C23