Enthsiasm about what?

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void reverserWord(char* string, int strlength);

int main(int argc, char* argv[])
{
        char* srcstring = "I will earn bigger money tomorrow";
        char* outstring = NULL;
        char tmp;
        char* cptr;
        int strlength;
        int i,j;
        outstring = malloc(strlen(srcstring)+1);
        if (outstring != NULL) {
                strlength = strlen(srcstring);
                strcpy(outstring, srcstring);
                outstring[strlength] = '\0';
                printf("Input string:%s\n", outstring);
                reverseWord(outstring, strlength);

                for (i = 0, j = 0; outstring[j]!= '\0'; j++) {
                        if ( (outstring[j] == ' ' && outstring[j+1] != ' ') ||
                              outstring[j+1] == '\0' ) {
                                cptr = &outstring[i];
                                strlength = j - i;
                                reverseWord(cptr, strlength);
                                i = j+1;
                        }
                }
                printf("output string %s\n", outstring);


                free(outstring);
        }
        return 0;
}

void reverseWord(char* string, int strlength)
{
        int i;
        char tmp;
        for ( i = 0 ; i < strlength /2 ; i++ ) {
                tmp = string[i];
                string[i] = string[strlength-i-1];
                string[strlength-i-1] = tmp;
        }
}

static void __init early_initrd(char **p)
{
unsigned long start, size;

start = memparse(*p, p);
if (**p == ',') {
size = memparse((*p) + 1, p);

phys_initrd_start = start;
phys_initrd_size = size;
}
}
__early_param("initrd=", early_initrd);


start_kernel:
    setup_arch:
        paging_init:
            bootmem_init:
                check_initrd(..) ifdef CONFIG_BLK_DEV_INITRD
                bootmem_reserve_initrd(..) ifdef CONFIG_BLK_DEV_INITRD
                    initrd_start = __phys_to_virt(phys_initrd_start);
                    initrd_end = initrd_start + phys_initrd_size;

static int __init kernel_init(void * unused)
{
    :
    do_basic_setup();
    :
    prepare_namespace();
}
static void __init do_basic_setup(void)
{
    rcu_init_sched(); /* needed by module_init stage. */
    init_workqueues();
    usermodehelper_init();
    driver_init();
    init_irq_proc();
    do_initcalls();
        /* the do_initcalls will eventually call a function:
           populate_rootfs(..) if CONFIG_BLK_DEV_RAM is defined, 
           then probably the init rootfs is a initrd, or a initramfs 
           if CONFIG_BLK_DEV_RAM is not defined
           then it only accepts initramfs
         */
}
void __init prepare_namespace(void)
{
    mount_block_root(root_device_name, root_mountflags);
    :
    if (initrd_load())
         go out
    :
    mount_root();
}

if (execute_command) {
run_init_process(execute_command);
printk(KERN_WARNING "Failed to execute %s.  Attempting "
"defaults...\n", execute_command);
}
run_init_process("/sbin/init");
run_init_process("/etc/init");
run_init_process("/bin/init");
run_init_process("/bin/sh");
:

    def __str__(self):
        if self.root is None: return '<empty tree>'
        def recurse(node):
            if node is None: return [], 0, 0
            label = str(node.key)
            left_lines, left_pos, left_width = recurse(node.left)
            right_lines, right_pos, right_width = recurse(node.right)
            middle = max(right_pos + left_width - left_pos + 1, len(label), 2)
            pos = left_pos + middle // 2
            width = left_pos + middle + right_width - right_pos
            while len(left_lines) < len(right_lines):
                left_lines.append(' ' * left_width)
            while len(right_lines) < len(left_lines):
                right_lines.append(' ' * right_width)
            if (middle - len(label)) % 2 == 1 and node.parent is not None and \
               node is node.parent.left and len(label) < middle:
                label += '.'
            label = label.center(middle, '.')
            if label[0] == '.': label = ' ' + label[1:]
            if label[-1] == '.': label = label[:-1] + ' '
            lines = [' ' * left_pos + label + ' ' * (right_width - right_pos),
                     ' ' * left_pos + '/' + ' ' * (middle-2) +
                     '\\' + ' ' * (right_width - right_pos)] + \
              [left_line + ' ' * (width - left_width - right_width) +
               right_line
               for left_line, right_line in zip(left_lines, right_lines)]
            return lines, pos, width
        return '\n'.join(recurse(self.root) [0])