Whitespace normalization, via reindent.py.

2 files changed, 302 insertions, 302 deletions

diff --git a/Mac/Demo/sound/morse.py b/Mac/Demo/sound/morse.py
index bf5fa5f..b26d554 100644
--- a/Mac/Demo/sound/morse.py
+++ b/Mac/Demo/sound/morse.py
@@ -2,61 +2,61 @@ import sys, math, audiodev
 
 DOT = 30
 DAH = 80
-OCTAVE = 2				# 1 == 441 Hz, 2 == 882 Hz, ...
+OCTAVE = 2                              # 1 == 441 Hz, 2 == 882 Hz, ...
 SAMPWIDTH = 2
 FRAMERATE = 44100
 BASEFREQ = 441
 QSIZE = 20000
 
 morsetab = {
-	'A': '.-',		'a': '.-',
-	'B': '-...',		'b': '-...',
-	'C': '-.-.',		'c': '-.-.',
-	'D': '-..',		'd': '-..',
-	'E': '.',		'e': '.',
-	'F': '..-.',		'f': '..-.',
-	'G': '--.',		'g': '--.',
-	'H': '....',		'h': '....',
-	'I': '..',		'i': '..',
-	'J': '.---',		'j': '.---',
-	'K': '-.-',		'k': '-.-',
-	'L': '.-..',		'l': '.-..',
-	'M': '--',		'm': '--',
-	'N': '-.',		'n': '-.',
-	'O': '---',		'o': '---',
-	'P': '.--.',		'p': '.--.',
-	'Q': '--.-',		'q': '--.-',
-	'R': '.-.',		'r': '.-.',
-	'S': '...',		's': '...',
-	'T': '-',		't': '-',
-	'U': '..-',		'u': '..-',
-	'V': '...-',		'v': '...-',
-	'W': '.--',		'w': '.--',
-	'X': '-..-',		'x': '-..-',
-	'Y': '-.--',		'y': '-.--',
-	'Z': '--..',		'z': '--..',
-	'0': '-----',
-	'1': '.----',
-	'2': '..---',
-	'3': '...--',
-	'4': '....-',
-	'5': '.....',
-	'6': '-....',
-	'7': '--...',
-	'8': '---..',
-	'9': '----.',
-	',': '--..--',
-	'.': '.-.-.-',
-	'?': '..--..',
-	';': '-.-.-.',
-	':': '---...',
-	"'": '.----.',
-	'-': '-....-',
-	'/': '-..-.',
-	'(': '-.--.-',
-	')': '-.--.-',
-	'_': '..--.-',
-	' ': ' '
+        'A': '.-',              'a': '.-',
+        'B': '-...',            'b': '-...',
+        'C': '-.-.',            'c': '-.-.',
+        'D': '-..',             'd': '-..',
+        'E': '.',               'e': '.',
+        'F': '..-.',            'f': '..-.',
+        'G': '--.',             'g': '--.',
+        'H': '....',            'h': '....',
+        'I': '..',              'i': '..',
+        'J': '.---',            'j': '.---',
+        'K': '-.-',             'k': '-.-',
+        'L': '.-..',            'l': '.-..',
+        'M': '--',              'm': '--',
+        'N': '-.',              'n': '-.',
+        'O': '---',             'o': '---',
+        'P': '.--.',            'p': '.--.',
+        'Q': '--.-',            'q': '--.-',
+        'R': '.-.',             'r': '.-.',
+        'S': '...',             's': '...',
+        'T': '-',               't': '-',
+        'U': '..-',             'u': '..-',
+        'V': '...-',            'v': '...-',
+        'W': '.--',             'w': '.--',
+        'X': '-..-',            'x': '-..-',
+        'Y': '-.--',            'y': '-.--',
+        'Z': '--..',            'z': '--..',
+        '0': '-----',
+        '1': '.----',
+        '2': '..---',
+        '3': '...--',
+        '4': '....-',
+        '5': '.....',
+        '6': '-....',
+        '7': '--...',
+        '8': '---..',
+        '9': '----.',
+        ',': '--..--',
+        '.': '.-.-.-',
+        '?': '..--..',
+        ';': '-.-.-.',
+        ':': '---...',
+        "'": '.----.',
+        '-': '-....-',
+        '/': '-..-.',
+        '(': '-.--.-',
+        ')': '-.--.-',
+        '_': '..--.-',
+        ' ': ' '
 }
 
 # If we play at 44.1 kHz (which we do), then if we produce one sine
@@ -64,117 +64,117 @@ morsetab = {
 # sine waves in these 100 samples, we get a tone of 882 Hz.  882 Hz
 # appears to be a nice one for playing morse code.
 def mkwave(octave):
-	global sinewave, nowave
-	sinewave = ''
-	n = int(FRAMERATE / BASEFREQ)
-	for i in range(n):
-		val = int(math.sin(2 * math.pi * i * octave / n) * 0x7fff)
-		sample = chr((val >> 8) & 255) + chr(val & 255)
-		sinewave = sinewave + sample[:SAMPWIDTH]
-	nowave = '\0' * (n*SAMPWIDTH)
+    global sinewave, nowave
+    sinewave = ''
+    n = int(FRAMERATE / BASEFREQ)
+    for i in range(n):
+        val = int(math.sin(2 * math.pi * i * octave / n) * 0x7fff)
+        sample = chr((val >> 8) & 255) + chr(val & 255)
+        sinewave = sinewave + sample[:SAMPWIDTH]
+    nowave = '\0' * (n*SAMPWIDTH)
 
 mkwave(OCTAVE)
 
 class BufferedAudioDev:
-	def __init__(self, *args):
-		import audiodev
-		self._base = apply(audiodev.AudioDev, args)
-		self._buffer = []
-		self._filled = 0
-		self._addmethods(self._base, self._base.__class__)
-	def _addmethods(self, inst, cls):
-		for name in cls.__dict__.keys():
-			if not hasattr(self, name):
-				try:
-					setattr(self, name, getattr(inst, name))
-				except:
-					pass
-		for basecls in cls.__bases__:
-			self._addmethods(self, inst, basecls)
-	def writeframesraw(self, frames):
-		self._buffer.append(frames)
-		self._filled = self._filled + len(frames)
-		if self._filled >= QSIZE:
-			self.flush()
-	def wait(self):
-		self.flush()
-		self._base.wait()
-	def flush(self):
-		print 'flush: %d blocks, %d bytes' % (len(self._buffer), self._filled)
-		if self._buffer:
-			import string
-			self._base.writeframes(string.joinfields(self._buffer, ''))
-			self._buffer = []
-			self._filled = 0
+    def __init__(self, *args):
+        import audiodev
+        self._base = apply(audiodev.AudioDev, args)
+        self._buffer = []
+        self._filled = 0
+        self._addmethods(self._base, self._base.__class__)
+    def _addmethods(self, inst, cls):
+        for name in cls.__dict__.keys():
+            if not hasattr(self, name):
+                try:
+                    setattr(self, name, getattr(inst, name))
+                except:
+                    pass
+        for basecls in cls.__bases__:
+            self._addmethods(self, inst, basecls)
+    def writeframesraw(self, frames):
+        self._buffer.append(frames)
+        self._filled = self._filled + len(frames)
+        if self._filled >= QSIZE:
+            self.flush()
+    def wait(self):
+        self.flush()
+        self._base.wait()
+    def flush(self):
+        print 'flush: %d blocks, %d bytes' % (len(self._buffer), self._filled)
+        if self._buffer:
+            import string
+            self._base.writeframes(string.joinfields(self._buffer, ''))
+            self._buffer = []
+            self._filled = 0
 
 def main(args = sys.argv[1:]):
-	import getopt, string
-	try:
-		opts, args = getopt.getopt(args, 'o:p:')
-	except getopt.error:
-		sys.stderr.write('Usage ' + sys.argv[0] +
-				 ' [ -o outfile ] [ args ] ...\n')
-		sys.exit(1)
-	dev = None
-	for o, a in opts:
-		if o == '-o':
-			import aifc
-			dev = aifc.open(a, 'w')
-			dev.setframerate(FRAMERATE)
-			dev.setsampwidth(SAMPWIDTH)
-			dev.setnchannels(1)
-		if o == '-p':
-			mkwave(string.atoi(a))
-	if not dev:
-		dev = BufferedAudioDev()
-		dev.setoutrate(FRAMERATE)
-		dev.setsampwidth(SAMPWIDTH)
-		dev.setnchannels(1)
-		dev.close = dev.stop
-	if args:
-		line = string.join(args)
-	else:
-		line = sys.stdin.readline()
-	while line:
-		print line
-		mline = morse(line)
-		print mline
-		play(mline, dev)
-		if hasattr(dev, 'wait'):
-			dev.wait()
-		if not args:
-			line = sys.stdin.readline()
-		else:
-			line = ''
-	dev.close()
+    import getopt, string
+    try:
+        opts, args = getopt.getopt(args, 'o:p:')
+    except getopt.error:
+        sys.stderr.write('Usage ' + sys.argv[0] +
+                         ' [ -o outfile ] [ args ] ...\n')
+        sys.exit(1)
+    dev = None
+    for o, a in opts:
+        if o == '-o':
+            import aifc
+            dev = aifc.open(a, 'w')
+            dev.setframerate(FRAMERATE)
+            dev.setsampwidth(SAMPWIDTH)
+            dev.setnchannels(1)
+        if o == '-p':
+            mkwave(string.atoi(a))
+    if not dev:
+        dev = BufferedAudioDev()
+        dev.setoutrate(FRAMERATE)
+        dev.setsampwidth(SAMPWIDTH)
+        dev.setnchannels(1)
+        dev.close = dev.stop
+    if args:
+        line = string.join(args)
+    else:
+        line = sys.stdin.readline()
+    while line:
+        print line
+        mline = morse(line)
+        print mline
+        play(mline, dev)
+        if hasattr(dev, 'wait'):
+            dev.wait()
+        if not args:
+            line = sys.stdin.readline()
+        else:
+            line = ''
+    dev.close()
 
 # Convert a string to morse code with \001 between the characters in
 # the string.
 def morse(line):
-	res = ''
-	for c in line:
-		try:
-			res = res + morsetab[c] + '\001'
-		except KeyError:
-			pass
-	return res
+    res = ''
+    for c in line:
+        try:
+            res = res + morsetab[c] + '\001'
+        except KeyError:
+            pass
+    return res
 
 # Play a line of morse code.
 def play(line, dev):
-	for c in line:
-		if c == '.':
-			sine(dev, DOT)
-		elif c == '-':
-			sine(dev, DAH)
-		else:
-			pause(dev, DAH)
-		pause(dev, DOT)
+    for c in line:
+        if c == '.':
+            sine(dev, DOT)
+        elif c == '-':
+            sine(dev, DAH)
+        else:
+            pause(dev, DAH)
+        pause(dev, DOT)
 
 def sine(dev, length):
-	dev.writeframesraw(sinewave*length)
+    dev.writeframesraw(sinewave*length)
 
 def pause(dev, length):
-	dev.writeframesraw(nowave*length)
+    dev.writeframesraw(nowave*length)
 
 if __name__ == '__main__' or sys.argv[0] == __name__:
-	main()
+    main()
diff --git a/Mac/Demo/sound/morselib.py b/Mac/Demo/sound/morselib.py
index 6f8eed6..98e2590 100644
--- a/Mac/Demo/sound/morselib.py
+++ b/Mac/Demo/sound/morselib.py
@@ -10,179 +10,179 @@ DOT = 30
 DAH = 80
 
 morsetab = {
-	'a': '.-',
-	'b': '-...',
-	'c': '-.-.',
-	'd': '-..',
-	'e': '.',
-	'f': '..-.',
-	'g': '--.',
-	'h': '....',
-	'i': '..',
-	'j': '.---',
-	'k': '-.-',
-	'l': '.-..',
-	'm': '--',
-	'n': '-.',
-	'o': '---',
-	'p': '.--.',
-	'q': '--.-',
-	'r': '.-.',
-	's': '...',
-	't': '-',
-	'u': '..-',
-	'v': '...-',
-	'w': '.--',
-	'x': '-..-',
-	'y': '-.--',
-	'z': '--..',
-	'0': '-----',
-	'1': '.----',
-	'2': '..---',
-	'3': '...--',
-	'4': '....-',
-	'5': '.....',
-	'6': '-....',
-	'7': '--...',
-	'8': '---..',
-	'9': '----.',
-	',': '--..--',
-	'.': '.-.-.-',
-	'?': '..--..',
-	';': '-.-.-.',
-	':': '---...',
-	"'": '.----.',
-	'-': '-....-',
-	'/': '-..-.',
-	'(': '-.--.-',
-	')': '-.--.-', # XXX same as code for '(' ???
-	'_': '..--.-',
-	' ': ' '
+        'a': '.-',
+        'b': '-...',
+        'c': '-.-.',
+        'd': '-..',
+        'e': '.',
+        'f': '..-.',
+        'g': '--.',
+        'h': '....',
+        'i': '..',
+        'j': '.---',
+        'k': '-.-',
+        'l': '.-..',
+        'm': '--',
+        'n': '-.',
+        'o': '---',
+        'p': '.--.',
+        'q': '--.-',
+        'r': '.-.',
+        's': '...',
+        't': '-',
+        'u': '..-',
+        'v': '...-',
+        'w': '.--',
+        'x': '-..-',
+        'y': '-.--',
+        'z': '--..',
+        '0': '-----',
+        '1': '.----',
+        '2': '..---',
+        '3': '...--',
+        '4': '....-',
+        '5': '.....',
+        '6': '-....',
+        '7': '--...',
+        '8': '---..',
+        '9': '----.',
+        ',': '--..--',
+        '.': '.-.-.-',
+        '?': '..--..',
+        ';': '-.-.-.',
+        ':': '---...',
+        "'": '.----.',
+        '-': '-....-',
+        '/': '-..-.',
+        '(': '-.--.-',
+        ')': '-.--.-', # XXX same as code for '(' ???
+        '_': '..--.-',
+        ' ': ' '
 }
 
 def morsecode(s):
-	from string import lower
-	m = ''
-	for c in s:
-		c = lower(c)
-		if morsetab.has_key(c):
-			c = morsetab[c] + ' '
-		else:
-			c = '? '
-		m = m + c
-	return m
+    from string import lower
+    m = ''
+    for c in s:
+        c = lower(c)
+        if morsetab.has_key(c):
+            c = morsetab[c] + ' '
+        else:
+            c = '? '
+        m = m + c
+    return m
 
 
 class BaseMorse:
-	"base class for morse transmissions" 
-	
-	def __init__(self):
-		"constructor"
-		self.dots = DOT
-		self.dahs = DAH
-	
-	def noise(self, duration):
-		"beep for given duration"
-		pass
-	
-	def pause(self, duration):
-		"pause for given duration"
-		pass
-	
-	def dot(self):
-		"short beep"
-		self.noise(self.dots)
-	
-	def dah(self):
-		"long beep"
-		self.noise(self.dahs)
-	
-	def pdot(self):
-		"pause as long as a dot"
-		self.pause(self.dots)
-	
-	def pdah(self):
-		"pause as long as a dah"
-		self.pause(self.dahs)
-	
-	def sendmorse(self, s):
-		for c in s:
-			if c == '.': self.dot()
-			elif c == '-': self.dah()
-			else: self.pdah()
-			self.pdot()
-	
-	def sendascii(self, s):
-		self.sendmorse(morsecode(s))
-	
-	def send(self, s):
-		self.sendascii(s)
+    "base class for morse transmissions"
+
+    def __init__(self):
+        "constructor"
+        self.dots = DOT
+        self.dahs = DAH
+
+    def noise(self, duration):
+        "beep for given duration"
+        pass
+
+    def pause(self, duration):
+        "pause for given duration"
+        pass
+
+    def dot(self):
+        "short beep"
+        self.noise(self.dots)
+
+    def dah(self):
+        "long beep"
+        self.noise(self.dahs)
+
+    def pdot(self):
+        "pause as long as a dot"
+        self.pause(self.dots)
+
+    def pdah(self):
+        "pause as long as a dah"
+        self.pause(self.dahs)
+
+    def sendmorse(self, s):
+        for c in s:
+            if c == '.': self.dot()
+            elif c == '-': self.dah()
+            else: self.pdah()
+            self.pdot()
+
+    def sendascii(self, s):
+        self.sendmorse(morsecode(s))
+
+    def send(self, s):
+        self.sendascii(s)
 
 
 import Audio_mac
 class MyAudio(Audio_mac.Play_Audio_mac):
-	def _callback(self, *args):
-		if hasattr(self, 'usercallback'): self.usercallback()
-		apply(Audio_mac.Play_Audio_mac._callback, (self,) + args)
+    def _callback(self, *args):
+        if hasattr(self, 'usercallback'): self.usercallback()
+        apply(Audio_mac.Play_Audio_mac._callback, (self,) + args)
 
 
 class MacMorse(BaseMorse):
-	"Mac specific class to play Morse code"
-	
-	def __init__(self):
-		BaseMorse.__init__(self)
-		self.dev = MyAudio()
-		self.dev.setoutrate(FRAMERATE)
-		self.dev.setsampwidth(SAMPWIDTH)
-		self.dev.setnchannels(1)
-		self.dev.usercallback = self.usercallback
-		sinewave = ''
-		n = int(FRAMERATE / BASEFREQ)
-		octave = OCTAVE
-		from math import sin, pi
-		for i in range(n):
-			val = int(sin(2 * pi * i * octave / n) * 0x7fff)
-			sample = chr((val >> 8) & 255) + chr(val & 255)
-			sinewave = sinewave + sample[:SAMPWIDTH]
-		self.sinewave = sinewave
-		self.silence = '\0' * (n*SAMPWIDTH)
-		self.morsequeue = ''
-	
-	def __del__(self):
-		self.close()
-	
-	def close(self):
-		self.dev = None
-	
-	def pause(self, duration):
-		self.dev.writeframes(self.silence * duration)
-	
-	def noise(self, duration):
-		self.dev.writeframes(self.sinewave * duration)
-	
-	def sendmorse(self, s):
-		self.morsequeue = self.morsequeue + s
-		self.dev.usercallback()
-		self.dev.usercallback()
-		self.dev.usercallback()
-	
-	def usercallback(self):
-		if self.morsequeue:
-			c, self.morsequeue = self.morsequeue[0], self.morsequeue[1:]
-			if c == '.': self.dot()
-			elif c == '-': self.dah()
-			else: self.pdah()
-			self.pdot()
+    "Mac specific class to play Morse code"
+
+    def __init__(self):
+        BaseMorse.__init__(self)
+        self.dev = MyAudio()
+        self.dev.setoutrate(FRAMERATE)
+        self.dev.setsampwidth(SAMPWIDTH)
+        self.dev.setnchannels(1)
+        self.dev.usercallback = self.usercallback
+        sinewave = ''
+        n = int(FRAMERATE / BASEFREQ)
+        octave = OCTAVE
+        from math import sin, pi
+        for i in range(n):
+            val = int(sin(2 * pi * i * octave / n) * 0x7fff)
+            sample = chr((val >> 8) & 255) + chr(val & 255)
+            sinewave = sinewave + sample[:SAMPWIDTH]
+        self.sinewave = sinewave
+        self.silence = '\0' * (n*SAMPWIDTH)
+        self.morsequeue = ''
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        self.dev = None
+
+    def pause(self, duration):
+        self.dev.writeframes(self.silence * duration)
+
+    def noise(self, duration):
+        self.dev.writeframes(self.sinewave * duration)
+
+    def sendmorse(self, s):
+        self.morsequeue = self.morsequeue + s
+        self.dev.usercallback()
+        self.dev.usercallback()
+        self.dev.usercallback()
+
+    def usercallback(self):
+        if self.morsequeue:
+            c, self.morsequeue = self.morsequeue[0], self.morsequeue[1:]
+            if c == '.': self.dot()
+            elif c == '-': self.dah()
+            else: self.pdah()
+            self.pdot()
 
 
 def test():
-	m = MacMorse()
-	while 1:
-		try:
-			line = raw_input('Morse line: ')
-		except (EOFError, KeyboardInterrupt):
-			break
-		m.send(line)
-		while m.morsequeue: pass
+    m = MacMorse()
+    while 1:
+        try:
+            line = raw_input('Morse line: ')
+        except (EOFError, KeyboardInterrupt):
+            break
+        m.send(line)
+        while m.morsequeue: pass
 
 test()