Index: src/time/clock.c
===================================================================
--- src/time/clock.c	(revision 397c77f3eabd20d194d7f9f89a7358eb5a0e23f8)
+++ src/time/clock.c	(revision ad36bd6b718c19bc3e77af6d6f92441a3d17a4d1)
@@ -58,6 +58,6 @@
 	 * run all expired timeouts as you visit them.
 	 */
-	spinlock_lock(&the->cpu->timeoutlock);
-	while ((l = the->cpu->timeout_active_head.next) != &the->cpu->timeout_active_head) {
+	spinlock_lock(&CPU->timeoutlock);
+	while ((l = CPU->timeout_active_head.next) != &CPU->timeout_active_head) {
 		h = list_get_instance(l, timeout_t, link);
 		spinlock_lock(&h->lock);
@@ -71,28 +71,28 @@
 		timeout_reinitialize(h);
 		spinlock_unlock(&h->lock);	
-		spinlock_unlock(&the->cpu->timeoutlock);
+		spinlock_unlock(&CPU->timeoutlock);
 
 		f(arg);
 
-		spinlock_lock(&the->cpu->timeoutlock);
+		spinlock_lock(&CPU->timeoutlock);
 	}
-	spinlock_unlock(&the->cpu->timeoutlock);
+	spinlock_unlock(&CPU->timeoutlock);
 
 	/*
-	 * Do CPU usage accounting and find out whether to preempt the->thread.
+	 * Do CPU usage accounting and find out whether to preempt THREAD.
 	 */
 
-	if (the->thread) {
-		spinlock_lock(&the->cpu->lock);
-		the->cpu->needs_relink++;
-		spinlock_unlock(&the->cpu->lock);	
+	if (THREAD) {
+		spinlock_lock(&CPU->lock);
+		CPU->needs_relink++;
+		spinlock_unlock(&CPU->lock);	
 	
-		spinlock_lock(&the->thread->lock);
-    		if (!the->thread->ticks--) {
-			spinlock_unlock(&the->thread->lock);
+		spinlock_lock(&THREAD->lock);
+    		if (!THREAD->ticks--) {
+			spinlock_unlock(&THREAD->lock);
 			scheduler();
 		}
 		else {
-			spinlock_unlock(&the->thread->lock);
+			spinlock_unlock(&THREAD->lock);
 		}
 	}
Index: src/time/delay.c
===================================================================
--- src/time/delay.c	(revision 397c77f3eabd20d194d7f9f89a7358eb5a0e23f8)
+++ src/time/delay.c	(revision ad36bd6b718c19bc3e77af6d6f92441a3d17a4d1)
@@ -42,5 +42,5 @@
 
 	pri = cpu_priority_high();
-	asm_delay_loop(microseconds * the->cpu->delay_loop_const);
+	asm_delay_loop(microseconds * CPU->delay_loop_const);
 	cpu_priority_restore(pri);
 }
Index: src/time/timeout.c
===================================================================
--- src/time/timeout.c	(revision 397c77f3eabd20d194d7f9f89a7358eb5a0e23f8)
+++ src/time/timeout.c	(revision ad36bd6b718c19bc3e77af6d6f92441a3d17a4d1)
@@ -40,6 +40,6 @@
 void timeout_init(void)
 {
-	spinlock_initialize(&the->cpu->timeoutlock);
-	list_initialize(&the->cpu->timeout_active_head);
+	spinlock_initialize(&CPU->timeoutlock);
+	list_initialize(&CPU->timeout_active_head);
 }
 
@@ -71,5 +71,5 @@
 
 	pri = cpu_priority_high();
-	spinlock_lock(&the->cpu->timeoutlock);
+	spinlock_lock(&CPU->timeoutlock);
 	spinlock_lock(&t->lock);
     
@@ -77,5 +77,5 @@
 		panic("timeout_register: t->cpu != 0");
 
-	t->cpu = the->cpu;
+	t->cpu = CPU;
 	t->ticks = us2ticks(time);
 	
@@ -87,6 +87,6 @@
 	 */
 	sum = 0;
-	l = the->cpu->timeout_active_head.next;
-	while (l != &the->cpu->timeout_active_head) {
+	l = CPU->timeout_active_head.next;
+	while (l != &CPU->timeout_active_head) {
 		hlp = list_get_instance(l, timeout_t, link);
 		spinlock_lock(&hlp->lock);
@@ -110,5 +110,5 @@
 	 * Decrease ticks of t's immediate succesor by t->ticks.
 	 */
-	if (l != &the->cpu->timeout_active_head) {
+	if (l != &CPU->timeout_active_head) {
 		spinlock_lock(&hlp->lock);
 		hlp->ticks -= t->ticks;
@@ -117,5 +117,5 @@
 
 	spinlock_unlock(&t->lock);
-	spinlock_unlock(&the->cpu->timeoutlock);
+	spinlock_unlock(&CPU->timeoutlock);
 	cpu_priority_restore(pri);
 }