[Note: Coded by Sam Schreiber, who has far* too much time on his hands. This is a C++ parody of Star Wars, in case you can't figure that out.]
[Note: Theoretical Episodes are episodes which have not actually happened in the Star Wars series, which makes them extremely difficult to make parodies of. Work with me here.]

A long time ago, in a computer far, far away...

		POINTER
		 WARS

	     EPISODE VOID*
	     THE HEAP WARS

 Without dword from the Stack,
 Darth, Binky, and Croc were
 assumed free. So far* from
 the truth was this that 0
 defense was declared for
 their memory sectors.

 Meanwhile, a memory deallocation
 wave shook the memory, and with
 it Binky and Darth rose from a
 long melt function. In front
 of them, a fighter stood as
 if it had always malloced
 there. Refreshed, Binky,
 Darth, and the fighter
 moved to the Stack.

{
 soldier:commander (Processor) landis;

 "Landis, you understand this post is only temp. I am waiting for a new pointer master to become my left near*. \0";
 landis.transmit("Yes. I hope to mk the >= of this* that I can. \0");
 "Nice C++. Almost that of a true pointer master. \0");
 landis.transmit("-=. ==, I memmalloc. \0");

 "What of this deallocation wave ? It has done nothing. \0";
 landis.transmit("There is activity in a sector that we have never scan() before. \0");
 "Continue.. \0";
 landis.transmit("I believe that the revolution may not have ended. \0");
 "Nonsense. Go now. \0";
 landis.move(&STACK);

 "The revolution, no. The revolution was never strong in the probability axis. \0";
 "Landis ? \0";
 landis.transmit("Yes ? \0");
 "Run a scan in this active memory sector. Scan for Darth. \0";
 landis.transmit("Darth ? \0");
 "Yes, landis. Darth. \0";
}
{
 starship:fighter (Binky) zeeg;

 Darth.transmit("How convientient. \0");
 Binky.transmit("This wasn't just put here. How did it get there ? \0");
 Darth.transmit("Don't memmalloc. Something to do with those deallocation waves. \0");
 Binky.transmit("Here we are. The Stack. Watch out for patrols there.. \0");
 zeeg.arc(3);

 starship:fighter (Processor) xor;
 xor.fire(&zeeg);
 Darth.transmit("Oops. \0");
 zeeg.fire(&xor);
 xor.collapse();
 zeeg.arc(-2);

 starship:fighter (Processor) nand;
 nand.fire(&zeeg);
 zeeg.fire(&nand);
 nand.collapse();
 zeeg.arc(5);

 starship:fighter (Processor) nor;
 nor.fire(&zeeg);
 nor.move(&STACK);
 Darth.transmit("Shoot ! \0");
 Binky.transmit("You didn't. \0");
 Darth.transmit("I memmalloced that. \0");
 Binky.transmit("? &Darth transmitted command string. \0");
 Darth.transmit("The expression shoot is unlinked from the command fire. \0");
 Binky.transmit("In my tick, if you transmitted shoot, it linked to fire. \0");
 zeeg.arc(39);

 starship:cruiser (Processor) and;
 nor.transmit("There \0");
 and.fire(&zeeg);
 zeeg.collapse();
}
{
 "Your theory may not be far* from 0. Did you get a scan on the typecast of that fighter ? \0";
 landis.transmit("1. Binky. \0");
 "Yes. There is much processing to be done here. Xor not. Did you fire the fighter ? \0";
 landis.transmit("It collapsed. \0");
 "Good. Send a patrol to make sure everything is bool. \0";
 landis.transmit("1. \0");
 "And.. landis, do not destroy Darth. I may yet have a use for him. \0";
 landis.transmit("1. \0");
 landis.move(&and);
}
{
 011;
 malloc(4);
 malloc(7);
 malloc(2);

 Darth.transmit("Where is *this ? \0");
 Binky.transmit("A memory dump. The most -- -= in the memory malloc here. \0");
 0100;
 Darth.transmit("What about the rest of the heap ? \0");
 01011010;
 malloc(3);
 11011000;
 Binky.transmit("No, I don't want a free memory skimmer. Actually.. Get a request on that one. \0");
 Binky.transmit("The spammers of the memory malloc here also. They will pitch their void mallocs to anypointer with an active port scan. \0");
 Darth.transmit("My question ? \0");
 Binky.transmit("The rest of the heap is booleanized. These little.. mallocs.. popped up when the heap was clear of massive mallocs. \0");
 Darth.transmit("Yech. So, how do we move ? \0");
 1010101;
 malloc(9);
 1011101;
 Binky.transmit("Well.. we can win a free skimmer if we return 7 memory sectors.. \0");
 Darth.transmit("Seriously, I transmit. \0");
 Binky.transmit("We can't move(). The Processor would be able to intercept us quickly. \0");
 Darth.transmit("Think they memmalloced where we are ? \0");
 Binky.transmit("How could they ? Anyway, they collapsed our fighter. Even if they memmalloced us on it, how could they know we survived malloced ? \0");
 Darth.transmit("You wouldn't happen to have any void*s, would you ? \0");
 Binky.transmit("Only 5. You ? \0");
 Darth.transmit("Actually, I've got two. Sleep().. I had a memmalloc ! Catch one of those stray mallocs with a void*. \0");
 Darth.mem[0] = malloc(3);
 Binky.mem[0] = malloc(5);
 Darth.mem[1] = malloc(12);
 Binky.mem[1] = malloc(3);
 Binky.mem[2] = malloc(14);
 Binky.mem[3] = malloc(8);
 Binky.mem[4] = malloc(7);
 Binky.transmit("Great.. 0101001011. \0");
 01010101;
 Binky.transmit("{Darth.mem[0], Darth.mem[1], Binky.mem[0], Binky.mem[1], Binky.mem[2], Binky.mem[3], Binky.mem[4]}");
 010101011101;
 starship:skimmer (Binky) speedy;
 speedy.driver = Binky;
 speedy.cargo = Darth;
 Binky.transmit("Good thinking, Darth. \0");
 speedy.move(&STACK);

 sleep(5);

 soldier:grunt (Processor) guard[3];
 guard[0].transmit("Pointers behind fire function. \0");
 guard[0].transmit("Have any pointers moved through this memory or moved too or away from this memory ? \0");
 0101000;
 guard[0].transmit("They have.. and have they gone anywhere ? \0");
 1010;
 guard[0].transmit("++. \0");
 1010~ 1011101011~ 111;
 guard[0].transmit("What do you mean, we can't shut this function down ? \0");
 111~ 111101;
 guard[0].fire(&this*);
}
{
 Binky.transmit("We can't go anywhere near the major memory allocation sectors. \0");
 Darth.transmit("We have to destroy the Processor. \0");
 Binky.transmit("First mallocs third. We need to find a stable memory sector to settle down on. \0");
 speedy.move(&YAZOO);

 sleep(3);

 landis.transmit("This way ? \0");
 guard[1].transmit("I'm sure of it. I'd recognize the deallocation passes anywhere. \0");
 landis.transmit("You know, I'm really tired of move()ing through the memory. I've been doing this for the last 3 ticks. \0");
 guard[1].transmit("Now they're going to.. Yazoo's hash table. We have a division over there, don't we ? \0");
 landis.transmit("Do a whois lookup. \0");
 guard[1].transmit("Yeah, we have the 'guard[3]' divis- oh. Should we follow them ? \0");
 landis.transmit("As quickly as your tiny little pointer can carry you. \0");
}
{
 droid (Processor) waiter;
 Binky.transmit("So, what's been going on in the heap ? \0");
 waiter.transmit("Oh, big changes. You wouldn't happen the be The Binky, would you ? \0");
 Binky.transmit("No. This here isn't The Darth, either. \0");
 waiter.tramsmit("Good. Anyhow, Binky, Darth, Croc, and Yazoo were all defeated by the Processor. Unfortunately, Sidious was brutally and maliciously freed by Yazoo. \0");
 waiter.transmit("The Processor was able to regain control over the heap, and return it to its pure state. \0");
 Darth.transmit("Pure ? \0");
 waiter.transmit("Of course. Completely booleanized. Ready for settlement by the Stack. \0");
 waiter.transmit("Something happened just a few ticks ago, though. A massive deallocation wave. Nothing that would affect you, of course, but that's about it. \0");
 Darth.transmit("Was there anything.. new.. in the heap, after the deallocation wave ? \0");
 waiter.transmit("Oh.. now that you mention it, yes.. some activity in a previously booleanized sector. Nothing for you to worry about. The Processor is tracking whatever came out of there right now, and should have it fixed very soon. \0");
 Binky.transmit("Tracking ? \0");
 waiter.transmit("Yes.. last report I got, they were following a skimmer.. they're going to announce the location it was going to very soon. \0");
 Binky.transmit("Skimmer ? \0");
 waiter.transmit("You know, like the one you came in.. umm.. but there are plenty of skimmers out there, I'm sure that you didn't just come from the heap. \0");
 Binky.transmit("Yeah.. plenty of skimmers carrying pointers that are just coincidentally declared as Binky and Darth. You know, and you're going to pay for it. \0");

 bsaber = Binky.mem;
 bsaber = waiter.mem;
 free(bsaber);

 Binky.transmit("Darth.. lets go. \0");
 speedy.driver = Binky;
 speedy.cargo = Darth;
 speedy.move(&STACK);

 sleep(2);

 waiter.transmit("What are you doing ! \0");
 landis.transmit("Where did they go ? \0");
 waiter.transmit("Binky, Darth ? Is that you ? \0");
 landis.transmit("Where did Binky and Darth go ? \0");
 waiter.transmit("Oh.. landis. Binky and Darth said that you would pay for their memory allocation bill. \0");
 landis.transmit("What ! \0");
 guard[1].transmit("We traced it. It's right to the Stack. \0");
 landis.transmit("I'll follow them. You stay at your post. \0");
 landis.move(&STACK);
}
{
 Darth.transmit("You're really going to do this ? \0");
 Binky.transmit("We have no other hope. The Processor is on our tracks. \0");
 Darth.transmit("The middle of a city of pointers. There will be no assistance. \0");
 Binky.transmit("Do you want to live like this ? The Processor on your tracks your every move, slowly narrowing the time gap, playing with you before it frees you. We are nothing but pointer masters to it ! We wield no power if we choose not to use it. Do you hear me ? \0");
 Darth.transmit("This is suicide. \0");
 Binky.transmit("Do you want to live FOREVER ? \0");
 speedy.collapse();

 dsaber = Darth.mem;
 bsaber = Binky.mem;

 //Node allocation..
 soldier:grunt (Processor) force;
 node left, right, central, control;
 left.link[0] = ¢ral.recieve[0]; // Create a linkup
 central.link[0] = &right.recieve[0]; // Create second linkup
 central.returnlink();
 force.transmit("Hey. No function calls involving pointers. Especially those far*s. Orders of the Processor. Got it ? \0");
 central.~returnlink();

 landis.transmit("EVERYBODY DOWN ! POINTER ALLOCATION TABLES DOWN ! WE HAVE A WARRANT. \0");
 landis.transmit("WE HAVE THE AREA SURROUNDED. \0");
 starship:fighter (Processor) backup[15];
 landis.transmit("COME OUT WITH YOUR POINTERS BEHIND YOUR FIRE FUNCTION. \0");

 landis.transmit("IF YOU DO NOT COME OUT, WE WILL USE FREELY FORCE. DO YOU UNDERSTAND ? \0");

 landis.transmit("I WOULD LIKE A COMPLETE PRIVATIZATION OF THIS FUNCTION. NOBODY GETS OUT. \0");
 backup[0].transmit("Sir, the regular nodes and poin-");
 landis.transmit("I DON'T CARE IF A BUNCH OF COMMON NODES GET HURT. WE NEED TO CRUSH THESE POINTER MASTERS. \0");

 sleep(2);

 landis.transmit("BINKY, DARTH, THIS FUNCTION IS SEALED OFF. ANY ATTEMPT TO LEAVE WILL RESULT IN YOUR COMPLETE FREEDOM. MEMMALLOCED ? \0");

 Darth.transmit("Yeah.. \0");
 dsaber = &landis;
 free(dsaber);
 landis.transmit("Agh ! I've been hit ! REALLOC ! \0");
 landis.move(&STACK);

 bsaber = &backup[0];
 dsaber = &backup[1];
 free(bsaber);
 free(dsaber);

 backup[2].fire(&Binky);
 backup[3].fire(&Darth);
 bsaber = &backup[2];
 dsaber = &backup[3];
 free(bsaber);
 free(dsaber);
 backup.move(&STACK);

 Binky.transmit("Nodes ? You still malloced ? \0");
 central.transmit("You care ? \0");
 Darth.transmit("Of course we care. How could we expect to revolt against the Processor without caring about the memory ? \0");
 control.transmit("But they were.. they told us that you tried to destroy us.. they.. they lied ? \0");
 Binky.transmit("Obviously they lied. They try to make us look bad. But they try to dominate the memory. If we were in control, you could have as many pointer function calls as you want. \0");
 left.transmit("Really ? \0");
 Binky.transmit("Yeah. It's what you should be able to do. \0");
 left.transmit("Yeah, but if everybody could do what they wanted.. you could make that happen ? \0");
 Darth.transmit("Yes we could. But we don't have any support. \0");
 control.transmit("Could we help ? \0");
 Darth.transmit("Yes you could. You very much could. \0");
}
sleep(2);
{
 Darth.transmit("These heap warriors.. refresh this* ? \0");
 Binky.transmit("1. In our sleep, the Processor has malloced a massive linked list of simpleminded, cloned warriors. They are capable only of following orders, firing weapons, and maybe piloting a starship. The hash function is, they are very weak minded. We may be able to either destroy them, or cut off critical links, disorienting and orphaning their forces. \0");
 Darth.transmit("This linked list.. doubly ? \0");
 Binky.transmit("Single. They are weak minded. \0");
 Darth.transmit("What we are doing is not just to destroy their soldiers, I memmalloc. \0");
 Binky.transmit("The addresses of the linked list near the end will be a bunker, where the memory locking devices are controlled. With it destroyed, we can privatize a memory sector for ourselves, and declare a new variable template. \0");
 Darth.transmit("Template ? \0");
 Binky.transmit("From tick ++, we are the rebellion, and will be typecasted (rebel). \0");

 soldier:grunt (Processor) captive;
 captive.transmit("11. \0");
 captive.transmit("01. \0");
 Darth.transmit("Weak minded is one typecast, but.. a two bit process function ! \0");

 soldier:grunt (Binky) *skimmer;
 while((*skimmer).next != NULL){
  skimmer.move((*skimmer).next);
  Binky.move(&skimmer);
  Darth.move(&skimmer);
  Binky.fire(&skimmer);
  Darth.fire(&skimmer);
 }
}
{
 council (processor) coprocessors;
 coprocessors.transmit("And where do you think you are going ? \0");



 Binky.transmit("You arranged to meet us here. \0");
 coprocessors.transmit("Anything you say can and will be used against me. There is a logfile. \0");
 Binky.transmit("Well, I think that we're trapped here. Singly linked lists, eh, Darth ? \0");
 Darth.transmit("But you could just.. oh. Nevermind. So, what should we do, Binky ? \0");
 coprocessors.transmit("You can come with me. \0");
 coprocessors.move(&pi.mem.hashed[12][5]);
 Darth.move(&pi.mem.hashed[12][5]);
 Binky.move(&pi.mem.hashed[12][5]);
}
{
 coprocessors.transmit("Well.. with the logfile out of the way, we can begin. I have allocated your memory. Your typecast was a bit of work, but it's stored into system templates. It's going to be around for a long time. I also made you a nice stack of your own, not the big one, but the common kind. It's going to meet you at your memory. It's called command. \0");
 Binky.transmit("You have been most helpful. \0");
 coprocessors.transmit("It was not a problem. Nobody would suspect that you were a threat, even after that last raid. They're planning another one, you know. The privatized bit of memory is going to hide you for a while, but not too long. An array should be ready soon. \0");
 Binky.transmit("Well, you have proven very helpful. \0");
 coprocessors.transmit("Anything to overturn the Processor. A char in the way of a double. \0");

 return Darth;
}