#iso speaks

[iso-draws]

Uhh hi everybody! I'm in need of some money right now so I'm opening up sketch commissions for custom shape ocs! They're $10 (US dollars) each and I accept payment through PayPal and Venmo. Please dm me on here or on Discord by the username @iso_draws if you're interested! Im accepting a shape head of your choice and a brief description of any themes or motifs for the character! Please hit me up if you're interested, thank you!

[fingors]

C — The Way It’s Written — Types

This is the first part in a possibly multi-part series of posts about the C programming language. It’s based not on common examples or what you’ll see your particular C compiler output, but on what’s written in the actual standard(s) that define the language. That being ISO/IEC 9899, in particular the 2018 revision (often named C17 or C18), however due to upcoming significant changes in the next revision (C2X), I’ll be skipping over a couple bits here and there that will be deprecated or removed by said revision, I’ll also revert to older versions if needed for special cases. All that being said, unless stated otherwise these posts are about C17. This series also assumes a baseline level familiarity with programming in general and expects you to know the general syntax style of C (if you’ve written or read and C++, Java, C#, or any similar language you’re good).

Due to the nature of C17 being an ISO/IEC document, it is not freely available for download, however the final working draft version of it is freely available, and there should be no significant changes between it and final. Link here.

Now, in what might seem like a very odd choice, we’re going to instantly skip to section 6 of the standard, not only that we’re skipping directly to 6.2.5 (page 31), because this is what defines the fundamental types of the language. Paragraphs 2, 4 and 6 are the important ones right now. From 2 we learn that the type _Bool (just bool in C2X) is at least large enough to hold the values 0 or 1 (hence its name, bool, short for boolean). Then we come to paragraph 4, which states there are 5 standard signed integer types: char, short, int, long, and long long (there’s also a statement about extended types but that can be ignored for the moment). Finally we hit paragraph 6, which simply states that all signed integer types have an unsigned equivalent that can be written by simply attaching the word unsigned to one of the types (ex. unsigned int), and that these 5 unsigned types combined with _Bool make up the set of unsigned types, and that any unsigned type takes up the same amount of storage/memory space as its corresponding signed type.

Moving back slightly to paragraph 5 we learn that signed char and char take the same amount of memory (and as such so does unsigned char), it also states that the int type should be the natural operating size of whatever machine architecture the code is being written for (so long as it satisfies a minimum value requirement). Moving forward to paragraph 9 we learn that, as you would expect, the signed types can store negative and positive values, and that the unsigned types can only store positive (or zero) values. We also learn that by definition unsigned values can not overflow, instead their value simply wraps around the range, however this is often referred to as overflow regardless.

Yet further down (paragraph 15, next page) we learn that char, signed char, and unsigned char are all different types, however char must match either char or unsigned char (the reasoning for this is that a compiler is free to choose the most efficient match for processing).

So with all that jumble out of the way what did we actually learn? Well: there exist 5 fundamental integer types: char, short, int, long, and long long, and that signed and unsigned versions of each exist, we also know there’s an unsigned type, _Bool that can represent the values 0 and 1. Together these make up the integer types of C.

Beyond integers there’s also floating point types, float, double, and long double, but those are a much more complicated subject that are outside the scope of this post. There’s also the void type, which has confusing wording that basically boils down to “you can’t use this, it represents nothing” (which is why functions with no return value have their return type marked void). And finally that you can make arrays out of these types (except void), make structure types that contain any number of these types (except void), make union types (complicated subject, think a box that can store only one type (except void) at a time), you can declare functions that return any type, you can have a pointer to any type (including void in order to represent a pointer to an unknown type), and finally that any type can be made atomic (safe for access from multiple threads).

Most of that statement can be freely ignored for now, it’s a mess that we’ll (hopefully) get into later. The important bit to know is that you can build other types out of the fundamental types.

Moving beyond that section and into 6.2.6 we learn from 6.2.6.1 Paragraphs 2-4 that objects (any type’s representation in memory basically) is made out of a continuous sequence of bytes. Moving to 6.2.6.2 we get to the representation of integer types, which is pretty much what you would expect for unsigned values (an unsigned integer of size n value bits can store 2n values from 0 to 2n-1), signed integer types in C17 list three different representations, however C2X is reducing that down to just twos’ complement (a signed integer of size n bits can store from -2n-1 to 2n-1-1, negative zeros are not possible).

So far: there exist integer types, and these store values in the expected way, but what are the range of values they must store?

Section 5.2.4.2.1 (page 20), paragraph 1 states that all implementations of the language must have the integer types be able to represent at least the values in the ranges listed below, meaning an implementation is free to expand the range if it sees fit (like how many do with int). From here we learn that a char must be at least 8 bits, and as such a signed char must be able to represent -127 (-128 in twos’ complement) to 127, and that an unsigned char is 0 to 255. Helpfully the actual (minimum) number of bits for each type is specified in a comment next to the definition. short is 16 bits/2 bytes, int is also 16 bits/2 bytes (again often expanded to 32 bits/4 bytes), long is 32 bits/4 bytes, and long long is 64 bits/8 bytes. _Bool due to its nature as a boolean type is not mentioned (actually any values placed into an object of type _Bool will become 0 if the value is 0 or 1 otherwise).

In summary: 6 types, _Bool (0 or 1), char (at least 8 bits), short (at least 16 bits), int (at least 16 bits, often 32), long (at least 32 bits), and long long (at least 64 bits).

So that’s it? For now yeah, those are the basic integer types of the C programming language, I know it was messy and weirdly formatted and confusing at times but I hope it helps understand the language a bit more, or at the very least was entertaining (even if that entertainment derived from “what the hell is this language?”). However, these complexities are part of the reason I love this language so much, everything is well defined but still variable depending on the system and compiler, there’s a reason for everything in this language ranging anywhere from “old” to “for performance reasons we can’t mandate this”, which if this series continues we’ll really get into. But for now, I hope this was enough of a taste of the standard to either make you interested in seeing more, or scare you the hell away forever. Thank you for reading and have a good time. If you have any suggestions for future parts or ways I could improve these writings please inform me. I need to go to sleep now.

[chronal-anomaly]

How do you defy your end?

a circus tent on the edge of time

you are the ringmaster and the animals and the performers all in one. a shapeshifter and a dancer. an entertainer. you have so much fun, every day and night, that you don't even know what's going on in those time locked places anymore. those who visit you speak of you like you've gone insane from having no one around to keep you company. maybe you have. does that matter though? when everything else is doomed to end and you, without question, will never end?

Tagged by: stole it

Tagging: @colecassiidy, @mercymedic @dimensionalspades (julian or leon), @byanyan @quick-drawn, and you

[sourcengine]

i still need to dig through the models of the half life dreamcast prototype to document the model differences, but its such a fucking doohickey setup

[woundedheartwithin]

Y’all remember when I posted a while back that I’d bought Yakuza on PS2? Finally got it to run!

It’s very slow on my laptop because my laptop sucks ass, but it actually looks great and plays nicely

And the dub?

Sublime

10/10 best purchase I ever made

[viovio]

how are you an outIast fan and still say unalive? say kill say fuck or else you'll die

[verberation]

I list of Aussie sayings that live in a very soft part of my heart;

Go, you good thing!

She’ll be right

Fang it

You beauty! (But pronounced how my grandpa Mogsy said it: you beaut-ay)

Onya mate!

Chuck a u-ey

Heaps good

Chuck a sickie

Anyway, the world is hard but I can tell my friends to chuck a u-ey and a small seed of fondness enters my body for the sheer spectacle and silliness of existing.

[gender-trash]

me: *talking to the cat voice* hi, babygirl!! does your litterbox continue to meet all applicable iso and ansi standards?

zenobia: meow

me: glad to hear it sweetie!

[iso-draws]

Hey update on the comic!!

Hai!! I have not forgotten about the comic, and apologies for the long wait for batch 2! I've been super busy as for me personally I am about to graduate high-school in 2 days!! Literally the graduation ceremony is this Saturday. So apologies on the wait for the next batch of comic pages. I promise I'll have way more time to work on it once I graduate 😅. Anywho thank you all for your support! New pages should be coming soon.

[meattruck]

I miss drawing (on the computer) so much I mean like I dont have time for it rn but the fact that it's not much of an option cuz my poor baby girl. I found about a different ISO called hiren cd pe thats an os on a flash w some more amenities so I can atleast check how my files are doing 🫠

[isolarya]

about me!

hello everyone, isolarya here! feel free to call me iso :D i am a fanfic writer and reader, as well as an original writer. writing is my longest and favourite hobby, and i love it! if you want, you can check out my writing on AO3 under isolarya!

here's a masterpost of my masterposts (so i don't clutter up my about me) that also has my au tags

i also have a sideblog for slay the princess, @chessheart

tags:

this is my life now - any irl related things (infrequent)

iso reblogs - reblogs!

she is speaking - posts that are tied to any behind the scenes stuff (posting dates, updates, asks, etc)

she answers - answering asks

ref - stuff I want saved

private - for me to find any privated posts

into my world of poetry - any poetry I write

writing stuff - anything writing related, not including fics

my writing - my fics or other prose stuff

my art - my (rare) art

inspiration - cool stuff I've found (usually prompts or ideas)

ideas - random stuff I think up for aus and fics

thoughts - non-fandom stuff that pops into my head and i feel like sharing

other stuff:

I love drama and theatre (even if I won't admit it)

my favourite genre is fantasy

I have the ability to jump into new fandoms I've never seen before (I do in fact have a story about this)

asks are welcome! (if you ask me questions about my fics or aus i will be very happy)

[twansgendew]

at some point i should change my theme again ive thought abt changing it back to a lemon demon thing from probably 2020 but i dont remember what it looked like exactly and idt i have the header image anymore

[fingors]

C — The Way It’s Written — Ranks & Bytes

This is part 2 in a series of posts about the C programing language, part 1 (and series details) can be found here

Well everyone, I hope you kept your copy of the free version of the standard from last time, 'cause that thing isn't going away any time soon. To give a quick rundown on what this part is going to cover, it's going to cover the rank of integer types, and it's going to go over the definition of a byte in the language and some of its consequences.

Rank

The “integer conversion rank” (6.3.1.1 p1, page 37) is a scale (or ranking) of all the integer types from _Bool to unsigned long long (and possibly implementation defined types). The definition effectively states that all integers have some rank, that the signed and unsigned version of a type have the same rank (and char’s rank equals that of its signed and unsigned versions), that a type with a greater precision (number of bits) will always have a greater rank than a lower one, and that even if two types have the same representation (ie. same width) one will always have a greater rank. It also gives us an outline of the rank of the fundamental (called the “standard integer types” in the document) integer types: _Bool, char, short, int, long, and long long, and it also handily gives us the info that any implementation defined types (such as say __int64) has a rank less than a corresponding standard type with the same rank (such as (possibly) long long). It also states that any implementation defined types with the same precision have some ranking between each other, this is important because it establishes a total order (any integer type’s rank is either less than or greater than any other type).

So what’s the deal with ranks? Well notice the full title contains “conversion”, ranks are very important for determining integer type promotion. Any type who’s precision (and as such rank) is less than an int will be transformed into an int (if its value would fit, unsigned int otherwise) when performing an arithmetic operation (add, sub, mul, div), a shift operation, a ‘sign’ operation (negation (- operator) or the + operator), or when passed “certain argument expressions” (usually var arg functions). Note this is simply a promotion in width only, the values contained within remain completely unchanged. What this means is that adding a char to a char will in fact actually become the addition of an int and an int.

Ranks are also very important for another conversion, arithmetic operations on differing types (6.3.1.8 p1, page 39). Firstly if one of the types in the expression is a floating point type long double, double, or float) then the other type is promoted to that floating point type (you don’t want to lose the fractional part just cause you added an int after all), but after that is where rank becomes important. If the types are the same nothing happens and the expression goes on as usual, but if the types differ then the type with the lower rank is promoted to the type with the higher rank (usually, there’s a caveat about precision that basically boils down to “if promoting it would cause signed data loss, then promote both types to an unsigned version”). What’s all this mean? Well it basically means that given any two types (say int and unsigned long long) any operation between them will cause the lower rank type to become the higher rank type (here the int becomes an unsigned long long).

These results are all bound to the definition of conversion (6.3.1.3, page 38). Long story short on that if you convert a signed type to an unsigned type then the value stored will have 2n (where n is the value bit width of the new type) added to it over and over until the result falls within range of the new type, however if you convert an unsigned type to a signed type and the value can not fit within the signed type its up to the implementation what happens (since its implementation defined it must be documented somewhere). Conversion also comes into play in a few other places, like assigning values of one type to another (ex. char to int) or passing arguments to functions (ex. passing an int value to a function expecting long).

Byte(s)

Ok this one is going to be a lot simpler (and more fundamental) than ranks, I’ve only put it after type introduction and ranks because it's easier to understand that way (at least for me, sorry if you find it otherwise).

Alright let’s get the big things out of the way first, a byte is simply defined as “addressable unit of data storage large enough to hold any member of the basic character set of the execution environment” (3.6, page 4), which just means it can hold all of the basic ASCII (printable) characters excluding ‘`’ (the backtick), ‘$’ and ‘@’ as well as some control characters like new lines and such. The other big thing is that a byte is at least 8 bits (5.2.4.2.1 p1, page 20), but can be more (there have been systems with 9 bit bytes before), and also that a char (and signed and unsigned versions) are exactly one byte, no more, no less.

The other thing is that any (non-bitfield) object (an object in C is defined in section 3 and is simply the value contained within some memory location) is composed of n continuous bytes (6.2.6.1 p4, page 34), meaning that the total width of the object in bytes is n multiplied by the number of bits in a byte. It also goes on to detail that any objects with the same bit pattern (except for floating point NaN values) will compare as equal, however not all objects that compare equal need to have the same bit pattern (ex. negative 0 and ‘normal’ 0).

Further down (6.2.6.2) we learn that any integer type (except unsigned char which is only value bits) can be divided into value bits (bits that contribute to the actual value of the number) and padding bits (bits that are just there to make the integer fill the full width of a n bytes), and that there need not be any padding bits. As expected an unsigned type can store any value between 0 and 2v-1, where v is the number of value bits, and a signed type can store between (at least) -2v-1 and 2v-1-1 (due to needing a sign bit).

All other objects have n bytes contained within them, however their usage of the bits will differ greatly depending on their use, for example floating point types need to divide their bits between sign, exponent, and mantissa, and structs use their bytes to hold other types and objects.

Conclusion

So that’s it, that’s ranks and bytes in the C programming language. Ranks determine how integer types combine together, and bytes make up every object in the language and determine their value.

Thank you for reading, once again I stayed up late to write this, except it's even worse since I have something critical tomorrow. If you have any comments, concerns, or ways to improve this series drop them in the replies.

[windmill-ghost]

I was thinking about this a while back when I was just getting into MGS but I’m remembering it again now that I’m thinking about Splatoon… if you really don’t think about it Raiden is just like Agent 8.

Has amnesia

Test subject

Raised in/for the military

Dragged around to do tasks by an unreliable and malevolent guide

Nadir of their story involves being stuck in the digestive system of a giant mecha and having to sneak around while totally vulnerable with no equipment

Impractical skintight outfit