This is how you read a number in 100% memory-safe type-safe C. Take note, rustrannies!

>>106153346 (OP)
>but saaaaaar using c makes me look badass since i call malloc saaaar please saar call me smart because i use malloc saaaaaaaaaar

>>106153346 (OP)
Is this an llm thing?

i had a stroke reading that code

>>106153414
No, it's from https://sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html

>>106153346 (OP)
This makes me miss my old job. Writing C programs really was a lot of fun.
I yearn for those days when I had written a couple thousand lines and was finally ready to start trying to compile, I would get a bunch of errors but slowly whittle them down until there's not so much as a warning and the program runs for the first time and I start to see the fruits of my labor. *chef's kiss*

https://github.com/openbsd/src/blob/master/lib/libc/stdlib/strtonum.c

(defun read-integer ()
(format t "Enter a number:~%")
(handler-case (values (parse-integer (read-line)))
(parse-error () (cerror "Try entering a number again." "That is not a number!~%") (read-integer))))

>>106155030
I like lisp's integers that default to being variable width. Makes a lot of prototyping algorithm really easy, instead of relying on mpfr/gmp calls

>>106155030
>no read error

>>106153346 (OP)
I wrote my own number conversion functions because I don't trust in the C library.

>>106153346 (OP)
make your life a little easier
https://docs.gtk.org/glib/method.IOChannel.read_line.html
https://docs.gtk.org/glib/func.ascii_strtoll.html

>>106153346 (OP)
>>106153362
Just use the standard library. Rust has more boilerplate than C and it has so much more of it that it's not even a contest.

>>106157498
>le global errno
Dude, just return a fucking error, at least they are not using the locale shit.

>>106153346 (OP)
Use case?

In Beef it's just
static int Main()
{
Loop:repeat
{
Console.Write("Enter a number: ");
let buffer = Console.ReadLine(.. scope .());

switch (int64.Parse(buffer))
{
case .Ok(let val):
Console.WriteLine("You've entered: {}", val);
break Loop;

case .Err(.Overflow):
Console.WriteLine("Sorry, this number is too small or too large");

case .Err(let err):
Console.WriteLine("Error: {}", err);
}
} while (true);

return 0;
}

>>106153346 (OP)

>>106155030
>lisp

End of discussion.

>>106153346 (OP)
#include <stdlib.h>

char line[256];
int n;
printf("Type an integer:\n");
getline(line, 256);
n = atoi(line);

>>106157783
>blue checkmark
>greentexting on twitter
>filtered by lifetimes
Tells me all I need to know

>>106158072

>>106158149
Doesn't /g/ hate systemd? Wouldn't this be an endorsement of sorts?

>>106153346 (OP)
jesus is this what AI code looks like? it looks like the kind of code i'd be embarrassed to see from a new hire.

>>106158149
Is there a way to disable Rust kernel modules?

>>106158149
>>106158174
>>106158509
fake screenshot
https://github.com/systemd/systemd/issues/18767#issuecomment-784570324

>>106158671
it was edited later its real

>>106154674
I hate the single return boomerism

usecase for user entered numbers or strings?

>>106157783
>>106158072
kai_fall is a retard h1b pajeet lmao
https://www.reddit.com/r/golang/comments/y9priy/go_vs_scala_vs_scss/?q=kai_fall&type=comments

every day this fucking retard starts a thread whining about either go or c, yet he clearly doesn't know either

>>106153346 (OP)
>100% memory-safe
what if they entered 1025 characters?

>>106157783
Rust is fine if you use it like C. Unfortunately most people don't write Rust like they write C.

Ok so write a small header library for macros/inline functions to check these things. I'm sure something exists that does this for you if you're really that retarded.

>>106154503
Holy cringe.

>>106157511
Just write your own library, you cuck. It's not that hard. libc is mostly locale-dependant dogshit.

>>106153346 (OP)
>>106160451
>Memory safety is when you're pedantic about error checking instead of showing an error dialog when a function returns an unexpected value
Yeah OP clearly doesn't know what he's talking about.
>>106160795
They said that about C++ too. Unlike C++ Rust doesn't have ABI compatibiltiy.

>>106160795
>Rust is fine
It really isn't.

>>106153346 (OP)
Good, so I just write that once and then I won't have to worry about my small program ballooning to 20MB?

>>106160678
check that a terminator exists in the buffer before using cstdlib string functions.
or don't use cstdlib string functions because its 2025 and we've known about the problems for 30 years

>>106154503
>the program runs for the first time and I start to see the fruits of my labor: *segfault*

>>106160678
fgets reads 1023 and sets the null terminator.

>>106162675
what happens when you call fgets again? is what's left of the previous buffer still there? i recall bumping into that behavior at some point

>>106162712
In that the rest would be in stdin's buffer. So in next iteration fgets reads those.

>>106162805
i thought either windows or linux threw it away, but maybe im high

>>106158207
I doubt you've ever worked a job let alone hired anyone

>>106163309
what's the matter, neet can't imagine someone being productive and contributing to society in a meaningful way?

Your brain is broken, did you get chatgpt to write that reply?

>>106153346 (OP)
int main(int argc, char* argv[])
no return statement
not storing and replacing the incoming errno
retarded comments

microsoft is cancer

>>106153346 (OP)
>char buf[1024]
An unsigned integer (uint64_t) only has like 20 characters (in decimal).

>>106160795
if you think rust is fine you are probably okay with pacifisim

>>106164429
can't you read the comment? "just to be sure"
degenerates like him belong on a cross and are why fucking notepad is burning 17% of my cpu and using 2.5 GB of ram to open a 1 MB text file

>>106153346 (OP)
Looks simple and readable to me. I don't get your problem.

>>106153346 (OP)
I'm nooting!

>>106160433
so just like most of /g/?

User input is considered gay in computer science. Only gay men want to take input, and they write programs. If you insist on being gay, go full on bug chaser with raw scanf.

>>106153346 (OP)
Keep up the studies with need more C men
>>106163413
Java is cancer, int argc, char* argv[] , should used unless the application is to use to it.

I guess you could only read comments, as single glance told me snipped was written by a man from the void, with a ugly neomodernistic style.

>>106165810
>they write programs.
*they write GAY programs

I know its bike shedding, but I always preferred to have ndone as a variable opposed to something like success. I never really liked having to negate my loop condition, with a ndone, you can set it to true for the task not being done and false once it completes.

>>106160795
If only there was a language that lets you write C code out of the box.

>>106165822
msvc started the void main(void) crap.
that program is spitting loads of compiler warnings, whats two more about unused variables?

>>106165822
>should used unless the application is to use to it.
Fuck no. It should be part of a library or something, like int getargscount(void) and const uint8_t* getargs(int) because that is how the OS works.

>>106153346 (OP)
>>106153562
>https://sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html
i lost iq from reading this article

i will find you op, and do unspeakable things to you

>>106166136
>that is how the OS works
what OS?
windows doesn't parse arguments

>>106157733
what is the :repeat after Loop label for? wtf is .. scope .() shit?

>>106158149
>systemd
>"basic building block for Linux systems"
kek

>>106166013
I like C but using shell scripts to build my project fucking sucks.
>inb4 use x build system
They are all, without fail, worse than using shell scripts.

>>106166837
embrace the suck that is cmake

>>106166837
>>106166846
mmmmmmakefile
NAME := nouvo

CC := gcc
CFLAGS := -O3 -march=native -funroll-all-loops -flto -fgnu89-inline -g

SOURCE_DIR := src/
INCLUDE_DIR := inc/
CURRENt_cell_path := $(PWD)

SOURCES := $(shell find . -name '*.c')
INCLUDES_PATHS := $(shell find . -name '*.h')
INCLUDES := $(foreach path, $(sort $(dir $(shell find $(CURRENt_cell_path) -name *.h))), -I $(path))

all :
clear
$(CC) $(CFLAGS) $(SOURCES) -o $(NAME) $(INCLUDES)

>>106166363
Yes, that is what I mean.

>>106166936
I'll give it a try. Ty white man.

>>106167005
you're welcome

>>106166936
Fucking nigger-

>>106166136
Java sickness at OS level

>>106153346 (OP)
scanf is not evil, it's simple and powerful

>>106153346 (OP)
>Sorry, this number is too small or too large.
Are you fucking insane?

>>106167174
>https://sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html

He just copy pasted a snippet

>>106167139
Some graybeards think you need error checking for "hello world!". I'm not even fucking joking.

>>106167257
My phone is a fag.

>>106157783
>somebody who chops off their own dick is a masochist
well color me surprised! who would have thunk?

>>106167083
im really not sure i wanna deal with this

>>106167139
What if the read fails and the unititialized example is between 1 and 6000?

>>106167314
Then you don't get to see a number. OH THE HUMANITY

>>106167337
Yes you do

>>106167257
Hahaha, the author is probably the idiot that submits to the new iso trash.

>>106153346 (OP)
We should do away with headers

>>106167314
Well you clearly failed to read

>>106167257
name this faggot with the bad grammar

>>106167257
This actually made me laugh

>>106167533
Seacord. Could honestly be anyone on the c committee though. They all think they're writing the next Critique of Pure Reason. They want the language to seem as perfectly unapproachable as possible.

>>106164863
A stack-allocated array costs literally nothing.

>>106167257
its an educational piece
you dont wanna be teaching bad habits
i agree with the author
learn to walk before you run

if more people got trained in the spirit of nigh-autistic attention to detail, c code would have been of much higher quality
i was, i learned in a peer learning setting where we checked eachother's programs
at first it made me paranoid but with experience this morphed into rock solid work habits

>>106167556
The only way I could even find of triggering an error was outputting to the bit bucket. I guess if you're trying to "hello world" on a wind up alarm clock, this "safe c" will really come in handy.

>>106158671
Why do cniles always lie?

>>106158745
Why doesn't it say it was edited next to post timestamp?

>>106167650
>t. projecting nocodeshitter

>>106167611
thats not really the point though, is it?
how many c programs have you seen where return values are never checked?

>>106167712
The author of that safe code abomination got to have fun learning c with gets() from r&k, but his "from scratch" intro book jumps from a brainfuck hello world to alignment specifiers in mere pages... with zero ramp up. Just completely out of the blue after telling us what an int is.

>>106167257

>>106167841

>>106153346 (OP)
Nice try, but I don't read.

>>106167841
...based? Why would I need yet another programming book to explain integers? Not every book needs to be aimed at the absolute beginners.

>>106168523
Sure. The book sells itself as being for absolute beginners. Fear not though. Despite introducing very complex and niche concepts like above, it doesn't cover them in any depth whatsoever.

Incidentally, it devotes dozens of pages to drilling into into and arithmetic. Not pointer arithmetic, but a bare metal examination what happens to individual bits during basic addition and subtraction.

Ints and chars are of course covered at nauseating length after perplexing the "absolute beginner" target of the book with near zero depth forays into endianess and function pointers, which are never to be mentioned again.

Point being. Don't read c committee guys books. They're not "for" anyone.

>>106158149
>IBM Power servers still exist
I thought that architecture died in like 2015? Nobody runs anything except arm64, amd64, and a few financial dinosaurs still running s390x compatibles these days.
Your server is either an Android phone mining bitcoin on USB-C or a Dell rackable and nothing else.

>>106153346 (OP)
Only C, JVM (Java, Clojure, Scala, Kotlin) and Haskell exist. All other languages are irrelevant
>I wanna webshit
Use a JVM language for the backend. If you use something that isn't a shit library like Spring Boot you're going to be ok, the JVM is really good with it's GC. Don't really like java? Use literally any other JVM based language.
>Quick CLI utility
Either Haskell or C, bash if it's really really simple. Haskell if you'll be parsing text. Parser combinators ftw.
>Performance intensive application
C or C-style C++, in the worst case (please no "modern" C++). No you don't need Rust, yes you can use Assembly if it's something that needs that much optimization.
>I want to do big data
JVM, once again
>AI! LLMs!
Java or C++. Python is a massive cope for this.
>I'm only learning programming to get a job
Java is the best language for enterprise bullshitting and moving papers around pretending to work (modern software development)

You shouldn't bother with any other languages

>>106167265
It's because 4chan strips the EXIF rotation metadata.

>>106169273
>implying JVM isn't C

>>106154674
I'm not that fluent in C.
When calling that function you'll pass a reference to a string to store an error in (const char **errstrp). You could pass NULL if you don't care. But if you pass a valid pointer and there is an error, the pointer will be set to a string that's defined within the function: *errstrp = ev[error].errstr;

Could that not cause issues? Like memory leaks if the memory is never freed, or use after free if it is?

>>106169273
> Java is the best language for enterprise bullshitting
it's no longer 1998. java shit is rapidly depreciating since oracle went full retard with licensing, forcing people to use the openjdk or just abandoning java completely.

>>106153346 (OP)
If I had to write a program that only reads numbers from stdin it'd look like this
#include <errno.h>
#include <unistd.h>

/* returns
* 0 success
* >0 error
* <0 EOF */
static int
next_int(int *p) {
static char buf[512];
static int i, n;
int err, sign, x;
int ret, c;
err = 1;
sign = 1;
x = 0;
for (; ; i++) {
if (i >= n) {
do
ret = read(0, buf, sizeof buf);
while (ret == -1 && errno == EINTR);
if (ret == -1)
return 1;
if (ret == 0) {
err = -err;
break;
}
n = ret;
i = 0;
}
c = buf[i];
if (err == 1)
switch (c) {
case '-':
sign = -1;
case '+':
err = 2;
case ' ': case '\n': case '\t':
continue;
}
if (c < '0' || c > '9')
break;
if (x >= 100000000)
return 1;
x = x*10 + c-'0';
err = 0;
}
if (!err)
*p = sign*x;
return err;
}

>>106172401
it's static const string, not allocated. no need to free it

>>106175344
Why is it static?

I mean, I'm sure it's fine given where it's from.

>>106173635
Never write C ever again

>>106175344
It's not static, chud, it's stack allocated.