Pre-compiled versions (Windows and OSX)

Source code

1. Use new lower case module names, not old ones. For example, email.mime.image.MIMEImage, instead of email.MIMEImage.MIMEImage.

2. import email.iterators, email.generator, and other staff that your exe complained missing.

I spent some time and crafted one. It is in python, so you should be able to run it on any platform. But I’m not a UI guy, so don’t expect too much.

You need pygame, PIL and feedparser to run it. Here is the link [appwall], feel free to try or improve it.

Update:

For those who don’t want to install a bunch of staff to try it, here is a exe version. My python installation on mac is totally a mess now. So, sorry, no app version.

Update2:

Fixed 2 bugs. The program is more stable now. Above links have been updated and point to newest version.

Install Mame build package & DirectX SDK
Open a Visual Studio Command Prompt (Start->All Programs->Microsoft Visual Studio 200x->Visual Studio Tools->Visual Studio 200x Command Prompt)
cd /mame_src/
set path=%PATH%;/path/to/mingw/bin
“c:\Program Files\Microsoft DirectX SDK (March 2009)\Utilities\bin\dx_setenv.cmd” x86
mingw32-make MSVC_BUILD=1 DEBUG=1 SYMBOLS=1 DIRECTINPUT=8 DIRECT3D=9
Open vmamed.exe for debug

The way that gzip compress files is easy to understand. 1. If a string repeats, we can simply say: rewind x bytes and copy y bytes from there. 2. Use Haffman code to further reduce file size.

However, deflate format is complicated, largely due to the way it represents Huffman trees. With some restrictions (see RFC1951 section 3.2.1 and 3.2.2), you only need to write down how many bits each leaf node has. Thus, a Huffman tree with N leaf nodes can be represented as an N-integer sequence.

Besides, gzip code is in an old fashioned format and not very reader friendly. Variables are named as b, kb, bb.  To undestand deflate format, I tried 3 files.

> echo hello > hello.txt
> gzip -c hello.txt > hello.gz

The content of hello.gz is

00000000  1F 8B 08 08 C0 C4 1D 4A 00 03 68 65 6C 6C 6F 2E .......J..hello.
00000010  74 78 74 00 CB 48 CD C9 C9 E7 02 00 20 30 3A 36 txt..H...... 0:6
00000020  06 00 00 00                                     ....

Compressed data is CB 48 CD C9 C9 E7 02 00.  Deflate format is a bit stream. The RFC defined that when packing bits into bytes, store into LSB first. In our example, the first byte is CB (1100 1011). So the first bit is the right most 1.  According to the RFC, this means we already reached the last data block. As we expected, we have only one data block here.

The next field is a 2-bit data field. According to the RFC, data fields are stored in their original bit order.  So we got ’01′, which means this data block is compressed with fixed Huffman codes. The way to pack bits into bytes are confusing for human, but easy for computers to carry out. See section 3.2.6 for coding schema. For ASCII code, the result is simply ascii+0×30.

Now, we reached the real data. Since data are coded by Huffman codes, length of next field depends on its content. Lets cheat here. We know that we are going to get an ‘h’, which is 8-bit long. RFC says Huffman codes should be packed MSB first. That is to say, we need to reverse the bits to get the real Huffman code. Next 8-bit is 00011001 (left 3 bits from the 2nd byte). Revers it we get 10011000. Minus 0×30 we get the ascii code for ‘h’, 1101000. Repeat this step, we’ll get “ello\n” and a termination mark (7 zero bits). Gzip’s implementation does not realy reverse the Huffman code, it use pre-computed tables to accelerate this step.

The 2nd example is
> echo hello hello > hello2.txt
> gzip -c hello2.txt > hello2.gz

The content of hello2.gz is

00000000  1F 8B 08 08 22 BE 1E 4A 00 03 68 65 6C 6C 6F 32 ...."..J..hello2
00000010  2E 74 78 74 00 CB 48 CD C9 C9 57 C8 00 91 5C 00 .txt..H...W...\.
00000020  A5 6A 0A 44 0C 00 00 00                         .j.D....

Following the procedure, we can easily get “hello h”. Then we got a 7-bit Huffman code, 0×02, which represents 258. 258 means repeat a 4-byte string in the output buffer. The RFC call this kind of code (258-285) length code, but I’d rather call them repeat code. Next one or two fields specify offset. In our case, we get 4 and 1. Following the 2nd table in RFC section 3.2.5, we get offset=6. Rewind 6 bytes and read 4 bytes from output buffer, we get “ello”. In this case, gzip did some compression, but it didn’t do its best.

The 3rd file is a real case:
> wget http://www.ietf.org/rfc/rfc1951.txt
> gzip -c rfc1951.txt > rfc1951.gz

The content of rfc1951.gz is:
00000000  1F 8B 08 08 31 25 A2 31 00 03 72 66 63 31 39 35 ….1%.1..rfc195
00000010  31 2E 74 78 74 00 B5 7D 6B 77 DB 46 92 E8 77 9D 1.txt..}kw.F..w.
00000020  FB 23 7A 7D CF 9E 90 31 49 11 7C E8 69 E7 AC 2C .#z}…1I.|.i..,
00000030  CB 8E 27 B2 D7 37 72 26 99 CC 7A E7 80 64 93 C4 ..’..7r&..z..d..
……

This time, gzip use dynamic Huffman codes. To make it simpler, I would explan compress process before jumping into the file.
1) generate 2 Huffman trees( called dictionary, one for alphabet and repeat marks, one for distance) and encoding the text file with these 2 trees.
2) recall that a Huffman tree can be represented as a sequence of integers. The dictionary can be repsented as 2 sequences. Totally 256(alphabet) + 1 (termination code) + 29(repeat code) + 30(distance) =  316 elements. In this step, we encode the dictionary with another Huffman tree. Maximum value in dictionary is 15 (=maximum depth of alphabet and repeat code tree). We gave 16, 17, 18 special meanings (see RFC section 3.2.7). Thus, this new tree has 18 nodes.

Alright, let’s look at the file. Header saids we have only 1 block, use dynamic Huffman coding, has 22 + 257 = 279 nodes in alphabet and repeat code tree, 1 + 29 = 30 nodes in the distance tree and 11 + 4 = 15 nodes in the 2nd level Huffman tree. In the 2nd level tree, 8, 7, 9, 6, 10 are represented as 3-bit code. (Note: although 8 appears before 6 according to the RFC, 6 still has lower code then 8). Decode the tree, we get 6->000, 7->001, … Then, we can decode the alphabet and repeat code tree. 00-09 does not appear, 0A (\n) as 8-bit value, …, 32 (space) as 5-bit, …

1) install apache2, jdk, etc.
2) install openfire. I didn’t use ubuntu package since I want to do some development later. Download it and extract to any folder would work.
3) sudo a2enmod proxy; sudo a2enmod proxy_http
4) enable and setup mod_proxy. Add the following code to your <VirtualHost>. I use /etc/apache2/site-available/default
<VirtualHost *>
….
<Proxy *>
Order allow,deny
Allow from all
</Proxy>
AddDefaultCharset UTF-8
ProxyPass /http-bind/ http://yoursite.com:7070/http-bind/
</VirtualHost>
Note: Don’t try to access yoursite.com:7070 from browser, you will get 400 or 404. This is fine.

5) Disable SASL in Jwchat.
In jsjac.js, change the following line:
var JSJACHBC_USE_BOSH_VER  = true; // change it to false

In jwchat.html, insert
oArg.authtype = ‘nonsasl’;
before
con.connect(oArg);

6) Log into openfire console and add the following 2 server properties.
xmpp.httpbind.client.requests.polling = 0
xmpp.httpbind.client.requests.wait = 10

7) Restart openfire and run /etc/init.d/apache2 force-reload

In this case, the small change of code worth it well. If this library was available when I was working on my last ray-tracing engine, my life would have been much easier. I wish someday, a similar library would be available on GPU.

I found another interesting thing during my test drive:

unsigned a, b = b0;
unsigned n = <a number you like>;
for(int i = 0; i < LOOP; ++i) {
a = b * b + n;
b = a * a + n;
}
No matter what b0 is, a and b will fall into a pair of fixed numbers (s1, s2), which only depend on value of n; If n is a odd number, then a != b. Otherwise, a = b = one of s1 and s2. I can’t prove it in math but I’ve verified b0=[0, 1024) and n=(0, 1024].

Here are some tips I learned in a recent project:
1) Implement you own new and delete operators.
2) Do not use exceptions. If you are porting a Windows driver, probably you don’t have to worry about this.
3) Do not use global non-trival variables. Since there is no C++ runtime in kernel, nobody will construct those variable for you. There are better ways to do it, singleton, factory, etc.
4) Implement platform-dependent functions. Making C++ code work with kerenl headers is not a simple job. I wrote this part in C. If you know a better way, plese let me know.
5) Compile your c++ code with -fno-builtin -fno-exceptions -fno-rtti -nostdinc, and link obj files to your platform-dependent part.

Ok, that’s it. I attached a sample project. If I missed anything, hopefully the code can explain it. (Why wordpress does not allow zip files? Is there any better way to post code including several files?)

// =======================================
// new.h, implement new and delete

#ifndef NEW_H
#define NEW_H

#include “kernel_api.h”

inline void *operator new(size_t s) {
return my_alloc(s);
}

inline void operator delete(void *p) {
return my_free(p);
}

// you may need other forms of new and delete
#endif

// =========================================
// kernel_api.h.
#ifndef KERNEL_API_H
#define KERNEL_API_H

#ifdef __cplusplus
extern “C” {
#endif

typedef unsigned int size_t;
#define KERN_INFO    “<6>”
#define NULL    0UL

extern void printk(const char *fmt, …);
extern void *my_alloc(size_t size);
extern void my_free(void *p);

#ifdef __cplusplus
}
#endif

#endif

//==========================================
// kernel_api.c
#include <linux/module.h>

void *my_alloc(size_t s) {
return kmalloc(s, GFP_KERNEL);
}

void my_free(void *p) {
return kfree(p);
}

//==========================================
// interface.c, required interface for every kernel module
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include “cppmod.h”

static int __init cppmod_init(void)
{
printk(KERN_INFO “cpp module installed\n”);
return 0;
}

static void __exit cppmod_exit(void)
{
printk(KERN_INFO “cpp module removed\n”);
}

module_init(cppmod_init);
module_exit(cppmod_exit);

MODULE_LICENSE(“GPL”);

//==========================================
// cppmod.h, exported C interface from C++ code
#ifndef CPP_MOD_H
#define CPP_MOD_H

#ifdef __cplusplus
extern “C” {
#endif

extern int start_driver(void* data);
extern void stop_driver(void);

#ifdef __cplusplus
}
#endif

#endif

//==========================================
//  cppmod.cpp, finally, my C++ code
#include “kernel_api.h”
#include “new.h”
#include “cppmod.h”

class Driver {
public:
Driver(unsigned int dev_id) : _id(dev_id) { printk(KERN_INFO “C++ driver started\n”); }
~Driver(void) { printk(KERN_INFO “Goodbye C++ driver\n”); }
private:
unsigned int _id;
};

static Driver *g_driver = NULL;

extern “C” int start_driver(void *data) {
g_driver = new Driver(*(unsigned int*)data);
if(!g_driver)
return -1;
return 0;
}

extern “C” void stop_driver(void) {
if(g_driver)
delete g_driver;
}

#####################################################
# Makefile
obj-m += mydrv.o
mydrv-objs := interface.o cppmod.o kernel_api.o
list-multi := mydrv.o

all: cppmod.o module
module:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

cppmod.o : cppmod.cpp new.h kernel_api.h cppmod.h
$(CC) -c -o $@ -fno-builtin -fno-exceptions -fno-rtti -nostdinc $<

In this post, I use Firebug’s Javascript Console to demonstrate my codes and their result. Firebug is a Javascript debugger for Firefox. It is also a good place to test drive Javascript.

Except a few primitive types, everything in Javascript is an Object. Objects are implemented as map (hash table). Consider the following object:
var user = { name : 'John', age : 20 };
You can either write
user.name
or
user['name']
Both will give you the same result. Member of an object can be a primitive variable, an object, or a function. Actually, in Javascript, function is a kind of object.

In Javascript, objects can only be accessed by reference. That means if you assign an object to another, you just created another reference to the same object. In this aspect, Javascript behaves like Java. For example:
>>> var o1 = { id : 1 };
>>> var o2 = o1;  // o1 and o2 point to the same object
>>> var o2.id = 2;
>>> o2.id = 2;
2
>>> o1.id    // o1.id get changed too
2

As I said before, in Javascript, a function is an object. It is just a object that can be called. You can think of it as a functor in C++. Actually, function has more “functions” in Javascript. A function can be called in 2 ways, as a normal function or as a constructor. When you write
a = myfunc();
you are calling myfunc() as a normal function. Instead, if you write
a = new myfunc();
you are calling myfunc() as a constructor.

When called as a constructor, a function first create a object called “this”. Then, it go though the function as usual. When the function returns, “this” will be returned and the original return will be discarded. Consider the following code:
function UserAccount(name, age) {
    this.name = name;
    this.age = age;
    return "I'll not be returned when called as a constructor";
} 
var user1 = new UserAccount('John', 20);
user1 will be an object consists “name” and “age”.  Here, “this” is quite confusing for C++ programmers. It has nothing to do with “this” pointer in C++. “this” is a object that browser created for you when you call a function as a constructor. In the above sample, we modified “this” and “this” was passed to user1 implicitly.

Another widely used and confusing feature is prototype. Javascript implements inheritance by prototype. But in  practice, prototype is simply used as another way to initialize a object. Then, why another way? To get the answer, we need to analyze the underling implementation.

 Every object has a hidden member called __proto__, which points to the object’s base object. When you try to read a member of an derived object, browser will search in the object’s properties first. If the derived object does not have the requested property, browser will search in its __proto__, then the __proto__’s __proto__. If you want to write into a non-existing member, browser will create the member and write into it. At the same time, every function has a property called “prototype”. By default, prototype is an empty object. You can modify it to fit your needs. When a function is called as a constructor, browser creates a object called “this” and points its “__proto__” to the function’s “prototype”. Since __proto__ is just a reference, the function’s prototype is shared by all object it constructed. The following code shows the underling implement of prototype:
>>> function UserAccount() {}
>>> UserAccount.prototype.name = 'John';
"John"
>>> user1 = new UserAccount();    // user1 does not have name, but prototype has one.
Object name=John
>>> user2 = new UserAccount();    // prototype is shared by user1 and user2
Object name=John
>>> user1.name = 'Tom';        // user1 has its own name now
"Tom"
>>> user2.name        // user2 is still using the prototype's name
"John"
>>> UserAccount.prototype.name = 'Alice';    // change prototype's name
"Alice"
>>> user1.name    // user1 unaffected
"Tom"
>>> user2.name    // user2 is still using the prototype's name
"Alice"

That’s it. Hopefully this post can help C++ users pick up Javascript easier.