“Foshizzle” is a modified version of the Clang compiler which supports Eubonicode++ (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 Eubonicode++ 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 Eubonicode (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 Eubonicode 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 Eubonicode++ 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 Eubonicode++ Mapping
| C++ | Eubonicode++ | | | C++ | Eubonicode++ |
|---|---|---|---|---|
#include |
#mahomie |
| | switch |
whatchugondo |
break |
bustanut |
| | this |
dis |
case |
ifa |
| | throw |
throz |
catch |
wrekdit |
| | true |
tru |
char |
alphabizzle |
| | try |
checkit |
class |
claz |
| | typedef |
reprezentin |
const |
foodonchange |
| | using |
uzin |
continue |
mo |
| | virtual |
frontin |
delete |
cap |
| | void |
shiznit |
else |
elz |
| | volatile |
trippin |
export |
bounce |
| | while |
slongas |
extern |
othahood |
| | ; |
bitch or biatch |
false |
falz |
| | = |
be |
float |
flo |
| | == |
sameas |
for |
fo |
| | != |
aint |
friend |
homie |
| | + |
an |
long |
shlong |
| | - |
widout |
namespace |
namespaze |
| | * |
dimes |
new |
makea |
| | / |
videdby |
private |
nonyobiz |
| | > |
bepimpin |
protected |
indafamily |
| | < |
fearin |
public |
tweetdat |
| | ++ |
propsta |
return |
putou |
| | -- |
dissin |
- *.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
- Create a new directory (e.g. “foshizzle”).
- Within the “foshizzle” directory, create the following directories: “build”, “src”, “install”
- Checkout the LLVM source code into the “src” directory:
svn co http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_30/rc4 ./src- Create a new directory for the Clang source within the LLVM “tools” directory:
mkdir src/tools/clang- 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- Change directories into the “build” directory.
- Configure the Clang/LLVM build and point it to the “install” directory you created earlier:
../src/configure --prefix=<path>/<to>/<foshizzle>/install- Build (takes quite a while):
make - Install:
make install - 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.
- Download my patch file: ebpp-clang30rc4.patch
- Change directories to where the Clang source is (src/tools/clang).
- Apply the patch:
patch -p0 -i ebpp-clang30rc4.patch - Change back to the “build” directory.
- Build:
make - Install:
make install - 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
