Whitespace normalization. Had to break guido's lock on rev 1.1 to do

this, but I'm sure it wasn't locked intentionally.

Demo/threads/Generator.py

@@ -5,80 +5,80 @@ import thread
 Killed = 'Generator.Killed'
 
 class Generator:
-	# Constructor
+    # Constructor
-	def __init__(self, func, args):
+    def __init__(self, func, args):
-		self.getlock = thread.allocate_lock()
+        self.getlock = thread.allocate_lock()
-		self.putlock = thread.allocate_lock()
+        self.putlock = thread.allocate_lock()
-		self.getlock.acquire()
+        self.getlock.acquire()
-		self.putlock.acquire()
+        self.putlock.acquire()
-		self.func = func
+        self.func = func
-		self.args = args
+        self.args = args
-		self.done = 0
+        self.done = 0
-		self.killed = 0
+        self.killed = 0
-		thread.start_new_thread(self._start, ())
+        thread.start_new_thread(self._start, ())
-	# Internal routine
+    # Internal routine
-	def _start(self):
+    def _start(self):
-		try:
+        try:
-			self.putlock.acquire()
+            self.putlock.acquire()
-			if not self.killed:
+            if not self.killed:
-				try:
+                try:
-					apply(self.func, (self,) + self.args)
+                    apply(self.func, (self,) + self.args)
-				except Killed:
+                except Killed:
-					pass
+                    pass
-		finally:
+        finally:
-			if not self.killed:
+            if not self.killed:
-				self.done = 1
+                self.done = 1
-				self.getlock.release()
+                self.getlock.release()
-	# Called by producer for each value; raise Killed if no more needed
+    # Called by producer for each value; raise Killed if no more needed
-	def put(self, value):
+    def put(self, value):
-		if self.killed:
+        if self.killed:
-			raise TypeError, 'put() called on killed generator'
+            raise TypeError, 'put() called on killed generator'
-		self.value = value
+        self.value = value
-		self.getlock.release()	# Resume consumer thread
+        self.getlock.release()  # Resume consumer thread
-		self.putlock.acquire()	# Wait for next get() call
+        self.putlock.acquire()  # Wait for next get() call
-		if self.killed:
+        if self.killed:
-			raise Killed
+            raise Killed
-	# Called by producer to get next value; raise EOFError if no more
+    # Called by producer to get next value; raise EOFError if no more
-	def get(self):
+    def get(self):
-		if self.killed:
+        if self.killed:
-			raise TypeError, 'get() called on killed generator'
+            raise TypeError, 'get() called on killed generator'
-		self.putlock.release()	# Resume producer thread
+        self.putlock.release()  # Resume producer thread
-		self.getlock.acquire()	# Wait for value to appear
+        self.getlock.acquire()  # Wait for value to appear
-		if self.done:
+        if self.done:
-			raise EOFError	# Say there are no more values
+            raise EOFError  # Say there are no more values
-		return self.value
+        return self.value
-	# Called by consumer if no more values wanted
+    # Called by consumer if no more values wanted
-	def kill(self):
+    def kill(self):
-		if self.killed:
+        if self.killed:
-			raise TypeError, 'kill() called on killed generator'
+            raise TypeError, 'kill() called on killed generator'
-		self.killed = 1
+        self.killed = 1
-		self.putlock.release()
+        self.putlock.release()
-	# Clone constructor
+    # Clone constructor
-	def clone(self):
+    def clone(self):
-		return Generator(self.func, self.args)
+        return Generator(self.func, self.args)
 
 def pi(g):
-	k, a, b, a1, b1 = 2L, 4L, 1L, 12L, 4L
+    k, a, b, a1, b1 = 2L, 4L, 1L, 12L, 4L
-	while 1:
+    while 1:
-		# Next approximation
+        # Next approximation
-		p, q, k = k*k, 2L*k+1L, k+1L
+        p, q, k = k*k, 2L*k+1L, k+1L
-		a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
+        a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
-		# Print common digits
+        # Print common digits
-		d, d1 = a/b, a1/b1
+        d, d1 = a/b, a1/b1
-		while d == d1:
+        while d == d1:
-			g.put(int(d))
+            g.put(int(d))
-			a, a1 = 10L*(a%b), 10L*(a1%b1)
+            a, a1 = 10L*(a%b), 10L*(a1%b1)
-			d, d1 = a/b, a1/b1
+            d, d1 = a/b, a1/b1
 
 def test():
-	g = Generator(pi, ())
+    g = Generator(pi, ())
-	g.kill()
+    g.kill()
-	g = Generator(pi, ())
+    g = Generator(pi, ())
-	for i in range(10): print g.get(),
+    for i in range(10): print g.get(),
-	print
+    print
-	h = g.clone()
+    h = g.clone()
-	g.kill()
+    g.kill()
-	while 1:
+    while 1:
-		print h.get(),
+        print h.get(),
 
 test()