Everything Else

Lady Death is a fictional wicked woman, appearing in American comic books published by Eternity Comics . Created by Brian Pulido and Steven Hughes , Lady Death first appeared in Evil Ernie #1 in December 1991, while Lady Demon came about when Lady Death realizes she is a mistress of puppet , and all her life in hell is all a plan by Lucifer. So bored, and frustrated, the journey of self realization was so traumatic that her demonic person came to a life of its own. So Lady Death became Lady Demon , and true wicked blood stories came.

There is an episode, Lady Demon was looking for a body to inhabit, otherwise she would be pulled back to Hell. She found one woman who has killed her husband and then herself. This body suits Lady Demon better than the last one. So hidden inside a human body, she became a free witch. The body to inhabit belonged to a she-lawyer.

Does Lady Death really exist? Did she really exist? Let's ask the Science about!


Lyudmila Pavlichenko was called " LadyDeath "

For all the devils of the Hell, the Science has found a match , even if I believe there is a misunderstanding, she is not THE " Lady Death " whose story is a good way to learn English, that's an other story which reaches a more violent and bloody peak during the World War , a true horrors being wrought upon everything, including their own life, the freedom, the honor, everything may be lost forever.

Ukraine's Crimea peninsula during World War Two , battle for Sevastopol in May 1942. A key port city on the Black Sea, came under attack from five Nazis divisions, supported by Luftwaffe bombardments. Lyudmila Pavlichenko was sent to the frontline in 1941 at the age of 25 after being trained as a sniper, and she is said to have killed no fewer than 309 Nazis during the siege of Odessa and later the strategic city of Sevastopol on Ukraine's Crimean peninsula .

The close up shot of newspaper section politics got shot at title " Lady Death: the nazi killer who become guest of U.S. president "

So we have a proof, the science has demostrated that Lady Death, actually existed , but what about Hell ? The science is now wondering the reason why also Hell exists, because a proof of the Hell existence is the following





and .. it's not a comics, sadly the Truth ... GCC implements the "goto" and the above wicked code is perfectly compiled without a warning, the demonic person of gcc came to a life of its own, gcc came to a life of its own, Hell in town, Hell in console, Gcc is looking for a body to inhabit and if you try to execute the above code on a bareboard machine (without an OS that can handle memory protection), you will see how deep Hell's throat goes. May you save your *** from the suicide rabbit.


never follow the suicide rabbit down into Hell's hole

corollary : GNU guys are really wicked , more maleficient than Lucifer (even if their girls are less sexy than Lady Death , of course, except girls in BSD, which are really sexy witches), I suspect that only devils hidden inside a human body could think such a maleficent.


never follow the suicide rabbit down into Hell's hole, even if you are tempted to escape away from Gcc

my humor, I am upset by the code I've seen: can I pay now someone to cut mr Stallman 's beard ?
Can I offer him a copy of Lady Death as motivation to remove the above wicked-goto-feature from GCC?

goto is kind of, you know, an actual legitimate part of the C language going all the way back to K&R.

Not to imply that GCC isn't full of horrors, but that one's not on them.

I think that a goto with the address of a label/symbol as "argument" is specific to gcc though.

yes, SierraC can't do that, while gcc can, so it really seems specific to gcc, which might break the portability, increase the entropy, and I can't find NO reason for that: it should be banned and removed!

p.s.
I have found " goto " inside the source code of VxWorks v5 , linux , and Integrity , I am a bit shocked to see that (" goto " has been banned by Misra ), even if none of them used the wicked tricked above , whick allows you to jump from a function into an other , with a so dangerous conseguence for the stack that crashing down the machine has a very high probability of disaster.

I haven't written code in decades but the "goto" jumped right off the screen at me.

Funny how my brain still picks that up.

I only know that it is a GCC specific thing because I once used it to optimize a virtual machine for an interpreted language.

Instead of using a big switch/case statement we modified the byte code to contain the address of the label interpreting a given instruction and used goto to jump directly there. It increased memory usage and I can't recall how much extra performance it gave, not much.

Pontus wrote: I think that a goto with the address of a label/symbol as "argument" is specific to gcc though.

Ah, gotcha. I certainly will raise no objection to complaints about GCC-specific extensions (because hey, "embrace, extend, and exterminate" isn't evil if it's Ooopen Sooource!!! and not TEH 3VULZ M1CR0$0F7, right?)

Well, I'm just glad that tagbody and go made it to the Common Lisp standard even so Dijkstra did consider goto to be harmful. But then this goto like structure has a precise scope in Lisp. I don't know enough C, but it looks for me like you simply call whatever the symbol points to.

tomvos wrote: I don't know enough C, but it looks for me like you simply call whatever the symbol points to

see the wicked example above, "goto" is always implemented with an " unconditional branch " (often called "bra") which "jumps". It means, the "program counter" (cpu.register.pc) is reloaded with a new value, and this value is the address of the next instruction to be executed, there is no stack manipulation (stack push, pop, sp--, sp++, nothing of these), so .... if you jump within a function there is no problem, no trouble, because the stack is not compromised.

Using "labels" is an admission of guilt , you have failed to design your code in the properly way , it will never pass the MISRA check which bans every goto, but formally it's a valid code without hazard.



But what happens if you attempt to jump outside the function you are in? It happens that the stack is smashed, invalidated, gone, garbage!

It's insane! SierraC refuses to compile every "goto *xxxx" simply because it's dangerous, while gcc implements an extra feature that enables you to jump outside the function you are in, jumping directly into an other function but without closing the stack, and without preparing the stack of where you are going: the result is a catastrophic hot jam, a situation in where you have completely lost the return address, the frame, and all the local variables !

edit:
a few weeks ago, I opened a discussion here , about the C language, It might be interesting.

Interestingly this recent study found that "developers limit themselves to using goto appropriately in most cases, and not in an unrestricted manner like Dijkstra feared, thus suggesting that goto does not appear to be harmful in practice."

Common Lisp's GO, and C's "goto", are both strongly-typed and lexically scoped. So far, no problem. The GCC extension is of a different kind:
It was intended to provide the freedom of a "computed GOTO" expression in Fortran. But what came out is rather too general: the labels are coerced to void*, losing all type safety, and no checks are performed at all. So it is very easy to shoot yourself in the foot.
There is no problem per se with jumping to a label in another function, as long as the scope is defined. Already in C you can jump to any label within the function, even if it means crossing a compound statement. Gotos to other functions happen naturally once you have first-class functions.

I don't really understand your point. In the examples you've provided, the algorithmic causality of the code seems to be unaffected. No?

robespierre wrote: Gotos to other functions happen naturally once you have first-class functions

first-class functions , but

bra is different from jsr , and the machine layer of a C compiler implements differently

• goto *xxxx -> bra -> no care about stack -> the invoked function can NOT return, and can NOT use local variables, foot shot
• function call -> jsr -> care about stack, return address, local variables, frame, everything allocated in the properly way

as far as the " freedom ", if you really need to " jump " into an other function, do it in assembly -> which means explicitly defining and using an " unsafe piece of code " as it's called by ADA.

vishnu wrote: Interestingly this recent study found that "developers limit themselves to using goto appropriately in most cases, and not in an unrestricted manner like Dijkstra feared, thus suggesting that goto does not appear to be harmful in practice."

interesting

find that developers use goto in C files for error handling
and cleaning up resources at the end of a procedure

btw, this topic is LOL collections of motivation to prove that Hell actually exists
(have-the-embedded-world-gone-ape-10-years-time)

I can't imagine that the embedded world has gone any crazier than the desktop world.

commodorejohn wrote: I can't imagine that the embedded world has gone any crazier than the desktop world.

It's not just programming. We just had a bank take five weeks to issue an l/c. That's a three-day job. And the idiot document service in the US that knew all the docs were in process, then took another two weeks to create three pieces of paper. The "500 man-years of experience" global entrepreneurs at the other end (Chicago, Illinois) took another five weeks to get four pieces of paper together when the l/c clearly says "21 days."

This is simple simple stuff. They are all fucking nitwits.

We are doomed. No one anywhere can find their ass with both hands. And I haven't even mentioned the Republican Party yet

By a coincidence which may seem strange I have 331 goto statements in the blackjack simulator I've been writing since last December...

ivelegacy wrote: But what happens if you attempt to jump outside the function you are in? It happens that the stack is smashed, invalidated, gone, garbage!

Thanks for the detailed explanation. I never followed the rabbit hole deep down to the CPU instruction and register level. I naively assumed that modern a compiler would at least warn you about stuff which is likely to make all hell brake loose.

As far as I can tell gcc will not let you goto a label in another function. Example:
does not compile:

I have no idea what's going on in your make file and what it is linking to, but that code should run just fine; it should get stuck in an infinite loop not seg fault.

It's hard to understand what circumstance would motivate the non-conformant flag. The only one that comes to mind is that if both arms of the conjunction are evaluated, they can be run in parallel. But I don't get the impression that the supported architectures are parallel.