“Foshizzle” is a modified version of the Clang compiler which supports Ebonicode++ (an alternate C++ syntax). Foshizzle supports all the existing features of Clang, but with extensions to more fully express your gansta style. All the regular C++ syntax still works, but you can now substitute Ebonicode++ keywords and operators (see below).

Here’s a sample method that calculates factorials (Note: the semicolons can be replaced with a certain expletive):

int factorialz(int n)
{
    int rezult be 1;
    slongas (n bepimpin 0)
    {
        rezult be rezult dimes n;
        dissin n;
    }
    putou rezult;
}

I can’t take all the credit. I was inspired by the Iowa State students that first created Ebonicode (webpage no longer available).

Here are my Clang modifications: ebpp-clang30rc4.patch

Build instructions are near the end of this post.

How It Happened

I periodically venture off into the h4x0r wilderness and pour myself into some random project. It always starts out innocently enough, but the project soon takes on a life of it’s own. This time was no different… except it happened over Thanksgiving (much to my wife’s chagrin).

Being the charismatic socialite that I am (sarcasm), I was digging through the C++11 spec on Thanksgiving. What struck me was how much of my language design course I had forgotten, and it really bugged me. It’s one of those required courses in the CompSci graduate program that I loathed having to take, but turned out to be invaluable (don’t get me started on the database and UI design courses… blah).

Long story less long, I started refreshing on compilers (read this for inspiration). I’d heard about Clang and LLVM awhile ago, and I remembered their focus on modularity, maintainability, and all sorts of other *ability’s. I figured it’d be a good place to start, so I download the source code and dug through it (watch this video for background on Clang).

Stepping through Clang in a debugger sounded like a great way to start, but I quickly had mental stack overflow through the recursive parsing code. Okay, time for plan B. Common wisdom says that a good way to learn a piece of code is to try and fix a bug. So I went to the Clang bug list looking for a starter task, but all the “interesting” tasks were way too large in scope for a Clang newb like me.

Time to invent plan C: make a small tweak to the language and see if I can get it working. I remembered a few years ago that some students from Iowa State built an Ebonicode compiler for a language class they had. It got quite a few laughs around the office and was always wishing for a working compiler. So I decided take their idea and replace ‘while’ with ‘slongas’… and an hour later I had it working (which is testament to the readability of the Clang code… it’s very well commented).

Not satisfied to stop there, I moved on to other keywords… simple, once you get comfortable with how the code’s laid out. “What about operators and punctuators?”, I wondered. After a few failed attempts, it dawned on me that C++ has aliases for operators (‘and_eq’ can be used in place of ‘&=’, etc). Instead of heavily modifying the parser/lexer, I started looking for how Clang handled these aliases… maybe I could just add some more. Turns out, it fairly simple to add new aliases, so ‘==’ got overloaded with ‘sameas’, ‘!=’ got overloaded with ‘aint’, etc… and it worked! Sweet!

After all that, I dug a little into the preprocessor and figured out how to support ‘#mahomie’ in place of ‘#include’. Simple enough. I dug a little into the build stuff and changed the name from ‘clang’ to ‘foshizzle’… cool. I little bit of frustration later, and I had it recognizing ‘*.opp’ and ‘*.ho’ as source and header files, respectively.

Three days after I started, I had a fully functional Ebonicode++ compiler and a lot deeper understanding of how a production C++ compiler works. I can’t stress enough that this project would never have happened if the Clang code wasn’t written so well. Kudos to the Clang team.

I really enjoyed this project, and I hope you get half the fun out of it I did. Next time you have a coding task, consider adding a litta gansta sizzle

C++ To Ebonicode++ Mapping

•  *.cpp -> *.opp
• *.h -> *.ho

Many thanks to Sean Tegtmeyer for helping with the syntax definition.

Building Foshizzle

I highly suggest building Clang without my changes first and verify that you have it working correctly. Then it should be simple to apply my patch and rebuild. I did all my work on Fedora 16, so your mileage may vary on other distros or OSes.

Note: If you have any problems building LLVM or Clang, please refer to their build page: Getting Started

1. Create a new directory (e.g. “foshizzle”).
2. Within the “foshizzle” directory, create the following directories: “build”, “src”, “install”
3. Checkout the LLVM source code into the “src” directory:
• svn co http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_30/rc4 ./src
4. Create a new directory for the Clang source within the LLVM “tools” directory:
• mkdir src/tools/clang
5. Checkout the Clang source code into the “src/tools/clang” directoy:
• svn co http://llvm.org/svn/llvm-project/cfe/tags/RELEASE_30/rc4 ./src/tools/clang
6. Change directories into the “build” directory.
7. Configure the Clang/LLVM build and point it to the “install” directory you created earlier:
• ../src/configure --prefix=<path>/<to>/<foshizzle>/install
8. Build (takes quite a while): make
9. Install: make install
10. Compile some test code to make sure it works: install/bin/clang++ yourtestcode.cpp

Only continue on once the unmodified version of Clang is working.

1. Download my patch file: ebpp-clang30rc4.patch
2. Change directories to where the Clang source is (src/tools/clang).
3. Apply the patch: patch -p0 -i ebpp-clang30rc4.patch
4. Change back to the “build” directory.
5. Build: make
6. Install: make install
7. Test: install/bin/foshizzle++ yordopecodez.opp

You can also build the sample code below.

Sample Code

baseclaz.ho, friendclaz.ho, main.opp

Building

install/bin/foshizzle++ main.opp

Program Output

baseclaz: protected = 1, private = 1
derivedclaz: protected = 0, private = 1
friendclaz: friend private = 0

Factorial(7) = 5040

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

If this video ever gets deleted from YouTube, you can download it HERE.

Fault bucket 42424242, type 1
Event Name: APPCRASH
Response: None
Cab Id: 0

Problem signature:
P1: MyApp.exe
P2: 1.42.42.42
P3: 598773cf
P4: StackHash_ac62
P5: 0.0.0.0
P6: 00000000
P7: c0000007
P8: 00000000
P9:
P10:

We spent some time wondering if our crypto libraries were the problem (we just made some changes recently), but concluded that was unlikely. So what the heck is the “StackHash” module? Did our trashed stack cause the kernel to think we were a different module? Nope.

The answer is that the Windows executive couldn’t identify the module we were in when the application crashed (it uses the instruction pointer to determine what code was executing). In this case, the kernel simply takes a hash of the stack so at least we might be able to identify if we’ve seen this exact crash before. Here’s the answer summarized by an engineer from Microsoft:

In the OS when I try to get a faulting module name it is possible that there is no module laoded (sic) at that address. For example in this case the EIP was zero. So in those cases where a module is not loaded and it is not also in the unloaded module list, I take a stack hash of the stack so that we can identify this crash from other crashes where also the module is not known.

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

It seems that Lenovo (the PC supplier for the games) chose Windows XP instead fo Vista. From the article:

Lenovo chairman, Yang Yuanqing, was quoted as saying that because of the complexity of the IT functions at the Games, it was decided to not use the the more recent operating system. “If it’s not stable, it could have some problems,” he said.

Ironically, former Microsoft CEO Bill Gates was in the crowd (he can run but he can’t hide).

Gizmodo has some more images and links to the incident.

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

And so the Death Star conspiracy goes:

We’ve all heard the “official conspiracy theory” of the Death Star attack. We all know about Luke Skywalker and his ragtag bunch of rebels, how they mounted a foolhardy attack on the most powerful, well-defended battle station ever built. And we’ve all seen the video over, and over, and over, of the one-in-a-million shot that resulted in a massive chain reaction that not just damaged, but completely obliterated that massive technological wonder.

Like many, I was fed this story when I was growing up. But as I watched the video, I began to realize that all was not as it seemed. And the more I questioned the official story, the deeper into the rabbit hole I went.

Read the full story HERE.

… and my favorite:

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

AMSTERDAM, Netherlands – Amsterdam police say 15 camels, two zebras and an undetermined number of llamas and potbellied swine briefly escaped from a traveling Dutch circus after a giraffe kicked a hole in their cage.

Police spokesman Arnout Aben says the animals wandered in a group through a nearby neighborhood for several hours after their 5:30 a.m. breakout.

The animals were back at the circus later Monday after being rounded up by police and circus workers with the assistance of dogs. Aben says neighbors fed some of the animals — which he said was a bad idea — but they were tame and nobody was hurt.

I have to agree with Bruce Schneier, “Are llamas really that hard to count?”.

… and here’s the classic scene that inspired this poster:

(requires Adobe Flash plugin… click HERE to watch it on YouTube)

(requires Adobe Flash plugin… click HERE to watch it on YouTube)