tn = telnetlib.Telnet(host, 0)
#
try:
- vt.send(tn.read_until('login: ', 10))
- tn.write('cwilib\r')
- #
- vt.send(tn.read_until('Hit <RETURN> to continue...', 10))
- tn.write('\r')
- #
- vt.send(tn.read_until('QUIT', 20))
+ vt.send(tn.read_until('login: ', 10))
+ tn.write('cwilib\r')
+ #
+ vt.send(tn.read_until('Hit <RETURN> to continue...', 10))
+ tn.write('\r')
+ #
+ vt.send(tn.read_until('QUIT', 20))
except EOFError:
- sys.stderr.write('Connection closed prematurely\n')
- sys.exit(1)
+ sys.stderr.write('Connection closed prematurely\n')
+ sys.exit(1)
#
define_screens(vt)
matches = vt.which_screens()
if 'menu' not in matches:
- sys.stderr.write('Main menu does not appear\n')
- sys.exit(1)
+ sys.stderr.write('Main menu does not appear\n')
+ sys.exit(1)
#
tn.write('\r\r')
vt.open('Progress -- CWI Library')
ui = UserInterface()
#
while 1:
- try:
- data = tn.read_very_eager()
- except EOFError:
- stdwin.message('Connection closed--goodbye')
- break
- if data:
- print 'send...'
- vt.send(data)
- print 'send...done'
- continue
- event = stdwin.pollevent()
- if event:
- type, window, detail = event
- if window == None and type == WE_LOST_SEL:
- window = ui.queryform.window
- event = type, window, detail
- if type == WE_CLOSE:
- break
- if window in ui.windows:
- ui.dispatch(type, window, detail)
- elif window == vt.window:
- if type == WE_NULL:
- pass
- elif type == WE_COMMAND:
- if detail == WC_RETURN:
- tn.write('\r')
- elif detail == WC_BACKSPACE:
- tn.write('\b')
- elif detail == WC_TAB:
- tn.write('\t')
- elif detail == WC_UP:
- tn.write('\033[A')
- elif detail == WC_DOWN:
- tn.write('\033[B')
- elif detail == WC_RIGHT:
- tn.write('\033[C')
- elif detail == WC_LEFT:
- tn.write('\033[D')
- else:
- print '*** Command:', detail
- elif type == WE_CHAR:
- tn.write(detail)
- elif type == WE_DRAW:
- vt.draw(detail)
- elif type in (WE_ACTIVATE, WE_DEACTIVATE):
- pass
- else:
- print '*** VT100 event:', type, detail
- else:
- print '*** Alien event:', type, window, detail
- continue
- rfd, wfd, xfd = select.select([tn, stdwin], [], [])
+ try:
+ data = tn.read_very_eager()
+ except EOFError:
+ stdwin.message('Connection closed--goodbye')
+ break
+ if data:
+ print 'send...'
+ vt.send(data)
+ print 'send...done'
+ continue
+ event = stdwin.pollevent()
+ if event:
+ type, window, detail = event
+ if window == None and type == WE_LOST_SEL:
+ window = ui.queryform.window
+ event = type, window, detail
+ if type == WE_CLOSE:
+ break
+ if window in ui.windows:
+ ui.dispatch(type, window, detail)
+ elif window == vt.window:
+ if type == WE_NULL:
+ pass
+ elif type == WE_COMMAND:
+ if detail == WC_RETURN:
+ tn.write('\r')
+ elif detail == WC_BACKSPACE:
+ tn.write('\b')
+ elif detail == WC_TAB:
+ tn.write('\t')
+ elif detail == WC_UP:
+ tn.write('\033[A')
+ elif detail == WC_DOWN:
+ tn.write('\033[B')
+ elif detail == WC_RIGHT:
+ tn.write('\033[C')
+ elif detail == WC_LEFT:
+ tn.write('\033[D')
+ else:
+ print '*** Command:', detail
+ elif type == WE_CHAR:
+ tn.write(detail)
+ elif type == WE_DRAW:
+ vt.draw(detail)
+ elif type in (WE_ACTIVATE, WE_DEACTIVATE):
+ pass
+ else:
+ print '*** VT100 event:', type, detail
+ else:
+ print '*** Alien event:', type, window, detail
+ continue
+ rfd, wfd, xfd = select.select([tn, stdwin], [], [])
# Subroutine to define our screen recognition patterns
def define_screens(vt):
vt.define_screen('menu', {
- 'title': ('search', 0, 0, 80,
- ' SEARCH FUNCTIONS +OTHER FUNCTIONS '),
- })
+ 'title': ('search', 0, 0, 80,
+ ' SEARCH FUNCTIONS +OTHER FUNCTIONS '),
+ })
vt.define_screen('search', {
- 'title': ('search', 0, 0, 80, ' Search '),
- })
+ 'title': ('search', 0, 0, 80, ' Search '),
+ })
vt.define_screen('shortlist', {'title': ('search', 0, 0, 80,
- ' Short-list')})
+ ' Short-list')})
vt.define_screen('showrecord', {
- 'title': ('search', 0, 0, 80, ' Show record '),
- })
+ 'title': ('search', 0, 0, 80, ' Show record '),
+ })
vt.define_screen('timelimit', {
- 'limit': ('search', 12, 0, 80, ' TIME LIMIT '),
- })
+ 'limit': ('search', 12, 0, 80, ' TIME LIMIT '),
+ })
vt.define_screen('attention', {
- 'BASE': ('copy', 0, 0, 0, 'search'),
- 'title': ('search', 10, 0, 80, ' ATTENTION ')})
+ 'BASE': ('copy', 0, 0, 0, 'search'),
+ 'title': ('search', 10, 0, 80, ' ATTENTION ')})
vt.define_screen('syntaxerror', {
- 'BASE': ('copy', 0, 0, 0, 'attention'),
- 'message': ('search', 12, 0, 80, ' Syntax error'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'attention'),
+ 'message': ('search', 12, 0, 80, ' Syntax error'),
+ })
vt.define_screen('emptyerror', {
- 'BASE': ('copy', 0, 0, 0, 'attention'),
- 'message': ('search', 12, 0, 80,
- ' Check your input. Search at least one term'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'attention'),
+ 'message': ('search', 12, 0, 80,
+ ' Check your input. Search at least one term'),
+ })
vt.define_screen('unsortedwarning', {
- 'BASE': ('copy', 0, 0, 0, 'attention'),
- 'message': ('search', 12, 0, 80,
- ' Number of records exceeds sort limit'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'attention'),
+ 'message': ('search', 12, 0, 80,
+ ' Number of records exceeds sort limit'),
+ })
vt.define_screen('thereismore', {
- 'BASE': ('copy', 0, 0, 0, 'showrecord'),
- 'message': ('search', 15, 0, 80,
- 'There is more within this record. Use the arrow keys'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'showrecord'),
+ 'message': ('search', 15, 0, 80,
+ 'There is more within this record. Use the arrow keys'),
+ })
vt.define_screen('nofurther', {
- 'BASE': ('copy', 0, 0, 0, 'showrecord'),
- 'message': ('search', 17, 0, 80, 'You cannot go further\.'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'showrecord'),
+ 'message': ('search', 17, 0, 80, 'You cannot go further\.'),
+ })
vt.define_screen('nofurtherback', {
- 'BASE': ('copy', 0, 0, 0, 'showrecord'),
- 'message': ('search', 17, 0, 80,
- 'You cannot go further back'),
- })
+ 'BASE': ('copy', 0, 0, 0, 'showrecord'),
+ 'message': ('search', 17, 0, 80,
+ 'You cannot go further back'),
+ })
# Class to implement our user interface.
class UserInterface:
def __init__(self):
- stdwin.setfont('7x14')
- self.queryform = QueryForm()
- self.listform = ListForm()
- self.recordform = RecordForm()
- self.forms = [self.queryform, self.listform, self.recordform]
- define_query_fields(self.queryform)
- self.windows = []
- for form in self.forms:
- if form.formheight > 0:
- form.open()
- self.windows.append(form.window)
+ stdwin.setfont('7x14')
+ self.queryform = QueryForm()
+ self.listform = ListForm()
+ self.recordform = RecordForm()
+ self.forms = [self.queryform, self.listform, self.recordform]
+ define_query_fields(self.queryform)
+ self.windows = []
+ for form in self.forms:
+ if form.formheight > 0:
+ form.open()
+ self.windows.append(form.window)
def __del__(self):
- self.close()
+ self.close()
def close(self):
- for form in self.forms:
- form.close()
+ for form in self.forms:
+ form.close()
def dispatch(self, type, window, detail):
- for form in self.forms:
- if window == form.window:
- form.dispatch(type, detail)
+ for form in self.forms:
+ if window == form.window:
+ form.dispatch(type, detail)
def define_query_fields(f):
class QueryForm(Form):
def __init__(self):
- Form.__init__(self, 'Query form -- CWI Library')
+ Form.__init__(self, 'Query form -- CWI Library')
def dispatch(self, type, detail):
- if type == WE_COMMAND and detail == WC_RETURN:
- print '*** SUBMIT ***'
- else:
- Form.dispatch(self, type, detail)
+ if type == WE_COMMAND and detail == WC_RETURN:
+ print '*** SUBMIT ***'
+ else:
+ Form.dispatch(self, type, detail)
class ListForm(Form):
def __init__(self):
- Form.__init__(self, 'Short list -- CWI Library')
+ Form.__init__(self, 'Short list -- CWI Library')
class RecordForm(Form):
def __init__(self):
- Form.__init__(self, 'Record detail -- CWI Library')
+ Form.__init__(self, 'Record detail -- CWI Library')
main()
import select
def main():
- server = 'cnri.reston.va.us' # How?
+ server = 'cnri.reston.va.us' # How?
port = 53
opcode = dnsopcode.QUERY
rd = 0
qname = sys.argv[1:] and sys.argv[1] or 'www.python.org'
m = dnslib.Mpacker()
m.addHeader(0,
- 0, opcode, 0, 0, rd, 0, 0, 0,
- 1, 0, 0, 0)
+ 0, opcode, 0, 0, rd, 0, 0, 0,
+ 1, 0, 0, 0)
m.addQuestion(qname, qtype, dnsclass.IN)
request = m.getbuf()
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((server, port))
s.send(request)
while 1:
- r, w, x = [s], [], []
- r, w, x = select.select(r, w, x, 0.333)
- print r, w, x
- if r:
- reply = s.recv(1024)
- u = dnslib.Munpacker(reply)
- dnslib.dumpM(u)
- break
+ r, w, x = [s], [], []
+ r, w, x = select.select(r, w, x, 0.333)
+ print r, w, x
+ if r:
+ reply = s.recv(1024)
+ u = dnslib.Munpacker(reply)
+ dnslib.dumpM(u)
+ break
main()
class C:
def m1(self, arg):
- require arg > 0
- return whatever
+ require arg > 0
+ return whatever
ensure Result > arg
can be written (clumsily, I agree) as:
class C(Eiffel):
def m1(self, arg):
- return whatever
+ return whatever
def m1_pre(self, arg):
- assert arg > 0
+ assert arg > 0
def m1_post(self, Result, arg):
- assert Result > arg
+ assert Result > arg
Pre- and post-conditions for a method, being implemented as methods
themselves, are inherited independently from the method. This gives
class D(C):
def m1(self, arg):
- return whatever**2
+ return whatever**2
def m1_post(self, Result, arg):
- C.m1_post(self, Result, arg)
- assert Result < 100
+ C.m1_post(self, Result, arg)
+ assert Result < 100
This gives derived classes more freedom but also more responsibility
than in Eiffel, where the compiler automatically takes care of this.
the requirement that arg > 0 could write:
def m1_pre(self, arg):
- pass
+ pass
but one could equally write a derived class that makes a stronger
requirement:
def m1_pre(self, arg):
- require arg > 50
+ require arg > 50
It would be easy to modify the classes shown here so that pre- and
post-conditions can be disabled (separately, on a per-class basis).
class EiffelMethodWrapper(MetaMethodWrapper):
def __init__(self, func, inst):
- MetaMethodWrapper.__init__(self, func, inst)
- # Note that the following causes recursive wrappers around
- # the pre-/post-condition testing methods. These are harmless
- # but inefficient; to avoid them, the lookup must be done
- # using the class.
- try:
- self.pre = getattr(inst, self.__name__ + "_pre")
- except AttributeError:
- self.pre = None
- try:
- self.post = getattr(inst, self.__name__ + "_post")
- except AttributeError:
- self.post = None
+ MetaMethodWrapper.__init__(self, func, inst)
+ # Note that the following causes recursive wrappers around
+ # the pre-/post-condition testing methods. These are harmless
+ # but inefficient; to avoid them, the lookup must be done
+ # using the class.
+ try:
+ self.pre = getattr(inst, self.__name__ + "_pre")
+ except AttributeError:
+ self.pre = None
+ try:
+ self.post = getattr(inst, self.__name__ + "_post")
+ except AttributeError:
+ self.post = None
def __call__(self, *args, **kw):
- if self.pre:
- apply(self.pre, args, kw)
- Result = apply(self.func, (self.inst,) + args, kw)
- if self.post:
- apply(self.post, (Result,) + args, kw)
- return Result
+ if self.pre:
+ apply(self.pre, args, kw)
+ Result = apply(self.func, (self.inst,) + args, kw)
+ if self.post:
+ apply(self.post, (Result,) + args, kw)
+ return Result
class EiffelHelper(MetaHelper):
__methodwrapper__ = EiffelMethodWrapper
def _test():
class C(Eiffel):
- def m1(self, arg):
- return arg+1
- def m1_pre(self, arg):
- assert arg > 0, "precondition for m1 failed"
- def m1_post(self, Result, arg):
- assert Result > arg
+ def m1(self, arg):
+ return arg+1
+ def m1_pre(self, arg):
+ assert arg > 0, "precondition for m1 failed"
+ def m1_post(self, Result, arg):
+ assert Result > arg
x = C()
x.m1(12)
## x.m1(-1)
To define your own enumeration, do something like
class Color(Enum):
- red = 1
- green = 2
- blue = 3
+ red = 1
+ green = 2
+ blue = 3
Now, Color.red, Color.green and Color.blue behave totally
different: they are enumerated values, not integers.
"""
def __init__(self, name, bases, dict):
- """Constructor -- create an enumeration.
-
- Called at the end of the class statement. The arguments are
- the name of the new class, a tuple containing the base
- classes, and a dictionary containing everything that was
- entered in the class' namespace during execution of the class
- statement. In the above example, it would be {'red': 1,
- 'green': 2, 'blue': 3}.
-
- """
- for base in bases:
- if base.__class__ is not EnumMetaClass:
- raise TypeError, "Enumeration base class must be enumeration"
- bases = filter(lambda x: x is not Enum, bases)
- self.__name__ = name
- self.__bases__ = bases
- self.__dict = {}
- for key, value in dict.items():
- self.__dict[key] = EnumInstance(name, key, value)
+ """Constructor -- create an enumeration.
+
+ Called at the end of the class statement. The arguments are
+ the name of the new class, a tuple containing the base
+ classes, and a dictionary containing everything that was
+ entered in the class' namespace during execution of the class
+ statement. In the above example, it would be {'red': 1,
+ 'green': 2, 'blue': 3}.
+
+ """
+ for base in bases:
+ if base.__class__ is not EnumMetaClass:
+ raise TypeError, "Enumeration base class must be enumeration"
+ bases = filter(lambda x: x is not Enum, bases)
+ self.__name__ = name
+ self.__bases__ = bases
+ self.__dict = {}
+ for key, value in dict.items():
+ self.__dict[key] = EnumInstance(name, key, value)
def __getattr__(self, name):
- """Return an enumeration value.
+ """Return an enumeration value.
- For example, Color.red returns the value corresponding to red.
+ For example, Color.red returns the value corresponding to red.
- XXX Perhaps the values should be created in the constructor?
+ XXX Perhaps the values should be created in the constructor?
- This looks in the class dictionary and if it is not found
- there asks the base classes.
+ This looks in the class dictionary and if it is not found
+ there asks the base classes.
- The special attribute __members__ returns the list of names
- defined in this class (it does not merge in the names defined
- in base classes).
+ The special attribute __members__ returns the list of names
+ defined in this class (it does not merge in the names defined
+ in base classes).
- """
- if name == '__members__':
- return self.__dict.keys()
+ """
+ if name == '__members__':
+ return self.__dict.keys()
- try:
- return self.__dict[name]
- except KeyError:
- for base in self.__bases__:
- try:
- return getattr(base, name)
- except AttributeError:
- continue
+ try:
+ return self.__dict[name]
+ except KeyError:
+ for base in self.__bases__:
+ try:
+ return getattr(base, name)
+ except AttributeError:
+ continue
- raise AttributeError, name
+ raise AttributeError, name
def __repr__(self):
- s = self.__name__
- if self.__bases__:
- s = s + '(' + string.join(map(lambda x: x.__name__,
- self.__bases__), ", ") + ')'
- if self.__dict:
- list = []
- for key, value in self.__dict.items():
- list.append("%s: %s" % (key, int(value)))
- s = "%s: {%s}" % (s, string.join(list, ", "))
- return s
+ s = self.__name__
+ if self.__bases__:
+ s = s + '(' + string.join(map(lambda x: x.__name__,
+ self.__bases__), ", ") + ')'
+ if self.__dict:
+ list = []
+ for key, value in self.__dict.items():
+ list.append("%s: %s" % (key, int(value)))
+ s = "%s: {%s}" % (s, string.join(list, ", "))
+ return s
class EnumInstance:
"""
def __init__(self, classname, enumname, value):
- self.__classname = classname
- self.__enumname = enumname
- self.__value = value
+ self.__classname = classname
+ self.__enumname = enumname
+ self.__value = value
def __int__(self):
- return self.__value
+ return self.__value
def __repr__(self):
- return "EnumInstance(%s, %s, %s)" % (`self.__classname`,
- `self.__enumname`,
- `self.__value`)
+ return "EnumInstance(%s, %s, %s)" % (`self.__classname`,
+ `self.__enumname`,
+ `self.__value`)
def __str__(self):
- return "%s.%s" % (self.__classname, self.__enumname)
+ return "%s.%s" % (self.__classname, self.__enumname)
def __cmp__(self, other):
- return cmp(self.__value, int(other))
+ return cmp(self.__value, int(other))
# Create the base class for enumerations.
def _test():
class Color(Enum):
- red = 1
- green = 2
- blue = 3
+ red = 1
+ green = 2
+ blue = 3
print Color.red
print dir(Color)
print Color.red == 2
class ExtendedColor(Color):
- white = 0
- orange = 4
- yellow = 5
- purple = 6
- black = 7
+ white = 0
+ orange = 4
+ yellow = 5
+ purple = 6
+ black = 7
print ExtendedColor.orange
print ExtendedColor.red
print Color.red == ExtendedColor.red
class OtherColor(Enum):
- white = 4
- blue = 5
+ white = 4
+ blue = 5
class MergedColor(Color, OtherColor):
- pass
+ pass
print MergedColor.red
print MergedColor.white
class MetaMethodWrapper:
def __init__(self, func, inst):
- self.func = func
- self.inst = inst
- self.__name__ = self.func.__name__
+ self.func = func
+ self.inst = inst
+ self.__name__ = self.func.__name__
def __call__(self, *args, **kw):
- return apply(self.func, (self.inst,) + args, kw)
+ return apply(self.func, (self.inst,) + args, kw)
class MetaHelper:
__methodwrapper__ = MetaMethodWrapper # For derived helpers to override
def __helperinit__(self, formalclass):
- self.__formalclass__ = formalclass
+ self.__formalclass__ = formalclass
def __getattr__(self, name):
- # Invoked for any attr not in the instance's __dict__
- try:
- raw = self.__formalclass__.__getattr__(name)
- except AttributeError:
- try:
- ga = self.__formalclass__.__getattr__('__usergetattr__')
- except KeyError:
- raise AttributeError, name
- return ga(self, name)
- if type(raw) != types.FunctionType:
- return raw
- return self.__methodwrapper__(raw, self)
+ # Invoked for any attr not in the instance's __dict__
+ try:
+ raw = self.__formalclass__.__getattr__(name)
+ except AttributeError:
+ try:
+ ga = self.__formalclass__.__getattr__('__usergetattr__')
+ except KeyError:
+ raise AttributeError, name
+ return ga(self, name)
+ if type(raw) != types.FunctionType:
+ return raw
+ return self.__methodwrapper__(raw, self)
class MetaClass:
"""
- __helper__ = MetaHelper # For derived metaclasses to override
+ __helper__ = MetaHelper # For derived metaclasses to override
__inited = 0
def __init__(self, name, bases, dict):
- try:
- ga = dict['__getattr__']
- except KeyError:
- pass
- else:
- dict['__usergetattr__'] = ga
- del dict['__getattr__']
- self.__name__ = name
- self.__bases__ = bases
- self.__realdict__ = dict
- self.__inited = 1
+ try:
+ ga = dict['__getattr__']
+ except KeyError:
+ pass
+ else:
+ dict['__usergetattr__'] = ga
+ del dict['__getattr__']
+ self.__name__ = name
+ self.__bases__ = bases
+ self.__realdict__ = dict
+ self.__inited = 1
def __getattr__(self, name):
- try:
- return self.__realdict__[name]
- except KeyError:
- for base in self.__bases__:
- try:
- return base.__getattr__(name)
- except AttributeError:
- pass
- raise AttributeError, name
+ try:
+ return self.__realdict__[name]
+ except KeyError:
+ for base in self.__bases__:
+ try:
+ return base.__getattr__(name)
+ except AttributeError:
+ pass
+ raise AttributeError, name
def __setattr__(self, name, value):
- if not self.__inited:
- self.__dict__[name] = value
- else:
- self.__realdict__[name] = value
+ if not self.__inited:
+ self.__dict__[name] = value
+ else:
+ self.__realdict__[name] = value
def __call__(self, *args, **kw):
- inst = self.__helper__()
- inst.__helperinit__(self)
- try:
- init = inst.__getattr__('__init__')
- except AttributeError:
- init = lambda: None
- apply(init, args, kw)
- return inst
+ inst = self.__helper__()
+ inst.__helperinit__(self)
+ try:
+ init = inst.__getattr__('__init__')
+ except AttributeError:
+ init = lambda: None
+ apply(init, args, kw)
+ return inst
Meta = MetaClass('Meta', (), {})
def _test():
class C(Meta):
- def __init__(self, *args):
- print "__init__, args =", args
- def m1(self, x):
- print "m1(x=%s)" %`x`
+ def __init__(self, *args):
+ print "__init__, args =", args
+ def m1(self, x):
+ print "m1(x=%s)" %`x`
print C
x = C()
print x
x.m1(12)
class D(C):
- def __getattr__(self, name):
- if name[:2] == '__': raise AttributeError, name
- return "getattr:%s" % name
+ def __getattr__(self, name):
+ if name[:2] == '__': raise AttributeError, name
+ return "getattr:%s" % name
x = D()
print x.foo
print x._foo
"""
def __init__(self):
- """Constructor. Initialize all instance variables."""
- self.__mutex = thread.allocate_lock()
- self.__wait = thread.allocate_lock()
- self.__tid = None
- self.__count = 0
+ """Constructor. Initialize all instance variables."""
+ self.__mutex = thread.allocate_lock()
+ self.__wait = thread.allocate_lock()
+ self.__tid = None
+ self.__count = 0
def acquire(self, flag=1):
- """Acquire the lock.
-
- If the optional flag argument is false, returns immediately
- when it cannot acquire the __wait lock without blocking (it
- may still block for a little while in order to acquire the
- __mutex lock).
-
- The return value is only relevant when the flag argument is
- false; it is 1 if the lock is acquired, 0 if not.
-
- """
- self.__mutex.acquire()
- try:
- if self.__tid == thread.get_ident():
- self.__count = self.__count + 1
- return 1
- finally:
- self.__mutex.release()
- locked = self.__wait.acquire(flag)
- if not flag and not locked:
- return 0
- try:
- self.__mutex.acquire()
- assert self.__tid == None
- assert self.__count == 0
- self.__tid = thread.get_ident()
- self.__count = 1
- return 1
- finally:
- self.__mutex.release()
+ """Acquire the lock.
+
+ If the optional flag argument is false, returns immediately
+ when it cannot acquire the __wait lock without blocking (it
+ may still block for a little while in order to acquire the
+ __mutex lock).
+
+ The return value is only relevant when the flag argument is
+ false; it is 1 if the lock is acquired, 0 if not.
+
+ """
+ self.__mutex.acquire()
+ try:
+ if self.__tid == thread.get_ident():
+ self.__count = self.__count + 1
+ return 1
+ finally:
+ self.__mutex.release()
+ locked = self.__wait.acquire(flag)
+ if not flag and not locked:
+ return 0
+ try:
+ self.__mutex.acquire()
+ assert self.__tid == None
+ assert self.__count == 0
+ self.__tid = thread.get_ident()
+ self.__count = 1
+ return 1
+ finally:
+ self.__mutex.release()
def release(self):
- """Release the lock.
+ """Release the lock.
- If this thread doesn't currently have the lock, an assertion
- error is raised.
+ If this thread doesn't currently have the lock, an assertion
+ error is raised.
- Only allow another thread to acquire the lock when the count
- reaches zero after decrementing it.
+ Only allow another thread to acquire the lock when the count
+ reaches zero after decrementing it.
- """
- self.__mutex.acquire()
- try:
- assert self.__tid == thread.get_ident()
- assert self.__count > 0
- self.__count = self.__count - 1
- if self.__count == 0:
- self.__tid = None
- self.__wait.release()
- finally:
- self.__mutex.release()
+ """
+ self.__mutex.acquire()
+ try:
+ assert self.__tid == thread.get_ident()
+ assert self.__count > 0
+ self.__count = self.__count - 1
+ if self.__count == 0:
+ self.__tid = None
+ self.__wait.release()
+ finally:
+ self.__mutex.release()
def _testLock():
done = []
def f2(lock, done=done):
- lock.acquire()
- print "f2 running in thread %d\n" % thread.get_ident(),
- lock.release()
- done.append(1)
+ lock.acquire()
+ print "f2 running in thread %d\n" % thread.get_ident(),
+ lock.release()
+ done.append(1)
def f1(lock, f2=f2, done=done):
- lock.acquire()
- print "f1 running in thread %d\n" % thread.get_ident(),
- try:
- f2(lock)
- finally:
- lock.release()
- done.append(1)
+ lock.acquire()
+ print "f1 running in thread %d\n" % thread.get_ident(),
+ try:
+ f2(lock)
+ finally:
+ lock.release()
+ done.append(1)
lock = Lock()
lock.acquire()
- f1(lock) # Adds 2 to done
+ f1(lock) # Adds 2 to done
lock.release()
lock.acquire()
lock.release()
import time
while len(done) < 9:
- print len(done)
- time.sleep(0.001)
+ print len(done)
+ time.sleep(0.001)
print len(done)
class LockingMethodWrapper(MetaMethodWrapper):
def __call__(self, *args, **kw):
- if self.__name__[:1] == '_' and self.__name__[1:] != '_':
- return apply(self.func, (self.inst,) + args, kw)
- self.inst.__lock__.acquire()
- try:
- return apply(self.func, (self.inst,) + args, kw)
- finally:
- self.inst.__lock__.release()
+ if self.__name__[:1] == '_' and self.__name__[1:] != '_':
+ return apply(self.func, (self.inst,) + args, kw)
+ self.inst.__lock__.acquire()
+ try:
+ return apply(self.func, (self.inst,) + args, kw)
+ finally:
+ self.inst.__lock__.release()
class LockingHelper(MetaHelper):
__methodwrapper__ = LockingMethodWrapper
def __helperinit__(self, formalclass):
- MetaHelper.__helperinit__(self, formalclass)
- self.__lock__ = Lock()
+ MetaHelper.__helperinit__(self, formalclass)
+ self.__lock__ = Lock()
class LockingMetaClass(MetaClass):
__helper__ = LockingHelper
def _test():
# For kicks, take away the Locking base class and see it die
class Buffer(Locking):
- def __init__(self, initialsize):
- assert initialsize > 0
- self.size = initialsize
- self.buffer = [None]*self.size
- self.first = self.last = 0
- def put(self, item):
- # Do we need to grow the buffer?
- if (self.last+1) % self.size != self.first:
- # Insert the new item
- self.buffer[self.last] = item
- self.last = (self.last+1) % self.size
- return
- # Double the buffer size
- # First normalize it so that first==0 and last==size-1
- print "buffer =", self.buffer
- print "first = %d, last = %d, size = %d" % (
- self.first, self.last, self.size)
- if self.first <= self.last:
- temp = self.buffer[self.first:self.last]
- else:
- temp = self.buffer[self.first:] + self.buffer[:self.last]
- print "temp =", temp
- self.buffer = temp + [None]*(self.size+1)
- self.first = 0
- self.last = self.size-1
- self.size = self.size*2
- print "Buffer size doubled to", self.size
- print "new buffer =", self.buffer
- print "first = %d, last = %d, size = %d" % (
- self.first, self.last, self.size)
- self.put(item) # Recursive call to test the locking
- def get(self):
- # Is the buffer empty?
- if self.first == self.last:
- raise EOFError # Avoid defining a new exception
- item = self.buffer[self.first]
- self.first = (self.first+1) % self.size
- return item
+ def __init__(self, initialsize):
+ assert initialsize > 0
+ self.size = initialsize
+ self.buffer = [None]*self.size
+ self.first = self.last = 0
+ def put(self, item):
+ # Do we need to grow the buffer?
+ if (self.last+1) % self.size != self.first:
+ # Insert the new item
+ self.buffer[self.last] = item
+ self.last = (self.last+1) % self.size
+ return
+ # Double the buffer size
+ # First normalize it so that first==0 and last==size-1
+ print "buffer =", self.buffer
+ print "first = %d, last = %d, size = %d" % (
+ self.first, self.last, self.size)
+ if self.first <= self.last:
+ temp = self.buffer[self.first:self.last]
+ else:
+ temp = self.buffer[self.first:] + self.buffer[:self.last]
+ print "temp =", temp
+ self.buffer = temp + [None]*(self.size+1)
+ self.first = 0
+ self.last = self.size-1
+ self.size = self.size*2
+ print "Buffer size doubled to", self.size
+ print "new buffer =", self.buffer
+ print "first = %d, last = %d, size = %d" % (
+ self.first, self.last, self.size)
+ self.put(item) # Recursive call to test the locking
+ def get(self):
+ # Is the buffer empty?
+ if self.first == self.last:
+ raise EOFError # Avoid defining a new exception
+ item = self.buffer[self.first]
+ self.first = (self.first+1) % self.size
+ return item
def producer(buffer, wait, n=1000):
- import time
- i = 0
- while i < n:
- print "put", i
- buffer.put(i)
- i = i+1
- print "Producer: done producing", n, "items"
- wait.release()
+ import time
+ i = 0
+ while i < n:
+ print "put", i
+ buffer.put(i)
+ i = i+1
+ print "Producer: done producing", n, "items"
+ wait.release()
def consumer(buffer, wait, n=1000):
- import time
- i = 0
- tout = 0.001
- while i < n:
- try:
- x = buffer.get()
- if x != i:
- raise AssertionError, \
- "get() returned %s, expected %s" % (x, i)
- print "got", i
- i = i+1
- tout = 0.001
- except EOFError:
- time.sleep(tout)
- tout = tout*2
- print "Consumer: done consuming", n, "items"
- wait.release()
+ import time
+ i = 0
+ tout = 0.001
+ while i < n:
+ try:
+ x = buffer.get()
+ if x != i:
+ raise AssertionError, \
+ "get() returned %s, expected %s" % (x, i)
+ print "got", i
+ i = i+1
+ tout = 0.001
+ except EOFError:
+ time.sleep(tout)
+ tout = tout*2
+ print "Consumer: done consuming", n, "items"
+ wait.release()
pwait = thread.allocate_lock()
pwait.acquire()
__inited = 0
def __init__(self, name, bases, dict):
- self.__name__ = name
- self.__bases__ = bases
- self.__dict = dict
- # XXX Can't define __dict__, alas
- self.__inited = 1
+ self.__name__ = name
+ self.__bases__ = bases
+ self.__dict = dict
+ # XXX Can't define __dict__, alas
+ self.__inited = 1
def __getattr__(self, name):
- try:
- return self.__dict[name]
- except KeyError:
- for base in self.__bases__:
- try:
- return base.__getattr__(name)
- except AttributeError:
- pass
- raise AttributeError, name
+ try:
+ return self.__dict[name]
+ except KeyError:
+ for base in self.__bases__:
+ try:
+ return base.__getattr__(name)
+ except AttributeError:
+ pass
+ raise AttributeError, name
def __setattr__(self, name, value):
- if not self.__inited:
- self.__dict__[name] = value
- else:
- self.__dict[name] = value
+ if not self.__inited:
+ self.__dict__[name] = value
+ else:
+ self.__dict[name] = value
def __call__(self, *args, **kw):
- inst = TracingInstance()
- inst.__meta_init__(self)
- try:
- init = inst.__getattr__('__init__')
- except AttributeError:
- init = lambda: None
- apply(init, args, kw)
- return inst
+ inst = TracingInstance()
+ inst.__meta_init__(self)
+ try:
+ init = inst.__getattr__('__init__')
+ except AttributeError:
+ init = lambda: None
+ apply(init, args, kw)
+ return inst
__trace_output__ = None
"""Helper class to represent an instance of a tracing class."""
def __trace_call__(self, fp, fmt, *args):
- fp.write((fmt+'\n') % args)
+ fp.write((fmt+'\n') % args)
def __meta_init__(self, klass):
- self.__class = klass
+ self.__class = klass
def __getattr__(self, name):
- # Invoked for any attr not in the instance's __dict__
- try:
- raw = self.__class.__getattr__(name)
- except AttributeError:
- raise AttributeError, name
- if type(raw) != types.FunctionType:
- return raw
- # It's a function
- fullname = self.__class.__name__ + "." + name
- if not self.__trace_output__ or name == '__trace_call__':
- return NotTracingWrapper(fullname, raw, self)
- else:
- return TracingWrapper(fullname, raw, self)
+ # Invoked for any attr not in the instance's __dict__
+ try:
+ raw = self.__class.__getattr__(name)
+ except AttributeError:
+ raise AttributeError, name
+ if type(raw) != types.FunctionType:
+ return raw
+ # It's a function
+ fullname = self.__class.__name__ + "." + name
+ if not self.__trace_output__ or name == '__trace_call__':
+ return NotTracingWrapper(fullname, raw, self)
+ else:
+ return TracingWrapper(fullname, raw, self)
class NotTracingWrapper:
def __init__(self, name, func, inst):
- self.__name__ = name
- self.func = func
- self.inst = inst
+ self.__name__ = name
+ self.func = func
+ self.inst = inst
def __call__(self, *args, **kw):
- return apply(self.func, (self.inst,) + args, kw)
+ return apply(self.func, (self.inst,) + args, kw)
class TracingWrapper(NotTracingWrapper):
def __call__(self, *args, **kw):
- self.inst.__trace_call__(self.inst.__trace_output__,
- "calling %s, inst=%s, args=%s, kw=%s",
- self.__name__, self.inst, args, kw)
- try:
- rv = apply(self.func, (self.inst,) + args, kw)
- except:
- t, v, tb = sys.exc_info()
- self.inst.__trace_call__(self.inst.__trace_output__,
- "returning from %s with exception %s: %s",
- self.__name__, t, v)
- raise t, v, tb
- else:
- self.inst.__trace_call__(self.inst.__trace_output__,
- "returning from %s with value %s",
- self.__name__, rv)
- return rv
+ self.inst.__trace_call__(self.inst.__trace_output__,
+ "calling %s, inst=%s, args=%s, kw=%s",
+ self.__name__, self.inst, args, kw)
+ try:
+ rv = apply(self.func, (self.inst,) + args, kw)
+ except:
+ t, v, tb = sys.exc_info()
+ self.inst.__trace_call__(self.inst.__trace_output__,
+ "returning from %s with exception %s: %s",
+ self.__name__, t, v)
+ raise t, v, tb
+ else:
+ self.inst.__trace_call__(self.inst.__trace_output__,
+ "returning from %s with value %s",
+ self.__name__, rv)
+ return rv
Traced = TraceMetaClass('Traced', (), {'__trace_output__': None})
def _test():
global C, D
class C(Traced):
- def __init__(self, x=0): self.x = x
- def m1(self, x): self.x = x
- def m2(self, y): return self.x + y
- __trace_output__ = sys.stdout
+ def __init__(self, x=0): self.x = x
+ def m1(self, x): self.x = x
+ def m2(self, y): return self.x + y
+ __trace_output__ = sys.stdout
class D(C):
- def m2(self, y): print "D.m2(%s)" % `y`; return C.m2(self, y)
- __trace_output__ = None
+ def m2(self, y): print "D.m2(%s)" % `y`; return C.m2(self, y)
+ __trace_output__ = None
x = C(4321)
print x
print x.x
"""Retrieve information from the parse tree of a source file.
fileName
- Name of the file to read Python source code from.
+ Name of the file to read Python source code from.
"""
source = open(fileName).read()
import os
_name = ''
def __init__(self, tree = None):
- self._class_info = {}
- self._function_info = {}
- if tree:
- self._extract_info(tree)
+ self._class_info = {}
+ self._function_info = {}
+ if tree:
+ self._extract_info(tree)
def _extract_info(self, tree):
- # extract docstring
- if len(tree) == 2:
- found, vars = match(DOCSTRING_STMT_PATTERN[1], tree[1])
- else:
- found, vars = match(DOCSTRING_STMT_PATTERN, tree[3])
- if found:
- self._docstring = eval(vars['docstring'])
- # discover inner definitions
- for node in tree[1:]:
- found, vars = match(COMPOUND_STMT_PATTERN, node)
- if found:
- cstmt = vars['compound']
- if cstmt[0] == symbol.funcdef:
- name = cstmt[2][1]
- self._function_info[name] = FunctionInfo(cstmt)
- elif cstmt[0] == symbol.classdef:
- name = cstmt[2][1]
- self._class_info[name] = ClassInfo(cstmt)
+ # extract docstring
+ if len(tree) == 2:
+ found, vars = match(DOCSTRING_STMT_PATTERN[1], tree[1])
+ else:
+ found, vars = match(DOCSTRING_STMT_PATTERN, tree[3])
+ if found:
+ self._docstring = eval(vars['docstring'])
+ # discover inner definitions
+ for node in tree[1:]:
+ found, vars = match(COMPOUND_STMT_PATTERN, node)
+ if found:
+ cstmt = vars['compound']
+ if cstmt[0] == symbol.funcdef:
+ name = cstmt[2][1]
+ self._function_info[name] = FunctionInfo(cstmt)
+ elif cstmt[0] == symbol.classdef:
+ name = cstmt[2][1]
+ self._class_info[name] = ClassInfo(cstmt)
def get_docstring(self):
- return self._docstring
+ return self._docstring
def get_name(self):
- return self._name
+ return self._name
def get_class_names(self):
- return self._class_info.keys()
+ return self._class_info.keys()
def get_class_info(self, name):
- return self._class_info[name]
+ return self._class_info[name]
def __getitem__(self, name):
- try:
- return self._class_info[name]
- except KeyError:
- return self._function_info[name]
+ try:
+ return self._class_info[name]
+ except KeyError:
+ return self._function_info[name]
class SuiteFuncInfo:
# Mixin class providing access to function names and info.
def get_function_names(self):
- return self._function_info.keys()
+ return self._function_info.keys()
def get_function_info(self, name):
- return self._function_info[name]
+ return self._function_info[name]
class FunctionInfo(SuiteInfoBase, SuiteFuncInfo):
def __init__(self, tree = None):
- self._name = tree[2][1]
- SuiteInfoBase.__init__(self, tree and tree[-1] or None)
+ self._name = tree[2][1]
+ SuiteInfoBase.__init__(self, tree and tree[-1] or None)
class ClassInfo(SuiteInfoBase):
def __init__(self, tree = None):
- self._name = tree[2][1]
- SuiteInfoBase.__init__(self, tree and tree[-1] or None)
+ self._name = tree[2][1]
+ SuiteInfoBase.__init__(self, tree and tree[-1] or None)
def get_method_names(self):
- return self._function_info.keys()
+ return self._function_info.keys()
def get_method_info(self, name):
- return self._function_info[name]
+ return self._function_info[name]
class ModuleInfo(SuiteInfoBase, SuiteFuncInfo):
def __init__(self, tree = None, name = "<string>"):
- self._name = name
- SuiteInfoBase.__init__(self, tree)
- if tree:
- found, vars = match(DOCSTRING_STMT_PATTERN, tree[1])
- if found:
- self._docstring = vars["docstring"]
+ self._name = name
+ SuiteInfoBase.__init__(self, tree)
+ if tree:
+ found, vars = match(DOCSTRING_STMT_PATTERN, tree[1])
+ if found:
+ self._docstring = vars["docstring"]
from types import ListType, TupleType
"""Match `data' to `pattern', with variable extraction.
pattern
- Pattern to match against, possibly containing variables.
+ Pattern to match against, possibly containing variables.
data
- Data to be checked and against which variables are extracted.
+ Data to be checked and against which variables are extracted.
vars
- Dictionary of variables which have already been found. If not
- provided, an empty dictionary is created.
+ Dictionary of variables which have already been found. If not
+ provided, an empty dictionary is created.
The `pattern' value may contain variables of the form ['varname'] which
are allowed to match anything. The value that is matched is returned as
values.
"""
if vars is None:
- vars = {}
- if type(pattern) is ListType: # 'variables' are ['varname']
- vars[pattern[0]] = data
- return 1, vars
+ vars = {}
+ if type(pattern) is ListType: # 'variables' are ['varname']
+ vars[pattern[0]] = data
+ return 1, vars
if type(pattern) is not TupleType:
- return (pattern == data), vars
+ return (pattern == data), vars
if len(data) != len(pattern):
- return 0, vars
+ return 0, vars
for pattern, data in map(None, pattern, data):
- same, vars = match(pattern, data, vars)
- if not same:
- break
+ same, vars = match(pattern, data, vars)
+ if not same:
+ break
return same, vars
(symbol.small_stmt,
(symbol.expr_stmt,
(symbol.testlist,
- (symbol.test,
- (symbol.and_test,
- (symbol.not_test,
- (symbol.comparison,
- (symbol.expr,
- (symbol.xor_expr,
- (symbol.and_expr,
- (symbol.shift_expr,
- (symbol.arith_expr,
- (symbol.term,
- (symbol.factor,
- (symbol.power,
- (symbol.atom,
- (token.STRING, ['docstring'])
- )))))))))))))))),
+ (symbol.test,
+ (symbol.and_test,
+ (symbol.not_test,
+ (symbol.comparison,
+ (symbol.expr,
+ (symbol.xor_expr,
+ (symbol.and_expr,
+ (symbol.shift_expr,
+ (symbol.arith_expr,
+ (symbol.term,
+ (symbol.factor,
+ (symbol.power,
+ (symbol.atom,
+ (token.STRING, ['docstring'])
+ )))))))))))))))),
(token.NEWLINE, '')
))
"This class does very little."
def method(self):
- "This method does almost nothing."
- return 1
+ "This method does almost nothing."
+ return 1
class Nested:
- "This is a nested class."
+ "This is a nested class."
- def nested_method(self):
- "Method of Nested class."
- def nested_function():
- "Function in method of Nested class."
- pass
- return nested_function
+ def nested_method(self):
+ "Method of Nested class."
+ def nested_function():
+ "Function in method of Nested class."
+ pass
+ return nested_function
def function():
"This function lives at the module level."
global _numFailed
print '----', fileName,
try:
- ast = parser.suite(t)
- tup = parser.ast2tuple(ast)
- # this discards the first AST; a huge memory savings when running
- # against a large source file like Tkinter.py.
- ast = None
- new = parser.tuple2ast(tup)
+ ast = parser.suite(t)
+ tup = parser.ast2tuple(ast)
+ # this discards the first AST; a huge memory savings when running
+ # against a large source file like Tkinter.py.
+ ast = None
+ new = parser.tuple2ast(tup)
except parser.ParserError, err:
- print
- print 'parser module raised exception on input file', fileName + ':'
- traceback.print_exc()
- _numFailed = _numFailed + 1
+ print
+ print 'parser module raised exception on input file', fileName + ':'
+ traceback.print_exc()
+ _numFailed = _numFailed + 1
else:
- if tup != parser.ast2tuple(new):
- print
- print 'parser module failed on input file', fileName
- _numFailed = _numFailed + 1
- else:
- print 'o.k.'
+ if tup != parser.ast2tuple(new):
+ print
+ print 'parser module failed on input file', fileName
+ _numFailed = _numFailed + 1
+ else:
+ print 'o.k.'
def testFile(fileName):
t = open(fileName).read()
import sys
args = sys.argv[1:]
if not args:
- import glob
- args = glob.glob("*.py")
+ import glob
+ args = glob.glob("*.py")
map(testFile, args)
sys.exit(_numFailed != 0)
class DirSupport:
def __init__(self):
- self._dirstack = []
+ self._dirstack = []
def __del__(self):
- self._close()
+ self._close()
def _close(self):
- while self._dirstack:
- self.back()
+ while self._dirstack:
+ self.back()
def pwd(self):
- return os.getcwd()
+ return os.getcwd()
def cd(self, name):
- save = os.getcwd()
- os.chdir(name)
- self._dirstack.append(save)
+ save = os.getcwd()
+ os.chdir(name)
+ self._dirstack.append(save)
def back(self):
- if not self._dirstack:
- raise os.error, "empty directory stack"
- dir = self._dirstack[-1]
- os.chdir(dir)
- del self._dirstack[-1]
+ if not self._dirstack:
+ raise os.error, "empty directory stack"
+ dir = self._dirstack[-1]
+ os.chdir(dir)
+ del self._dirstack[-1]
def listsubdirs(self, pat = None):
- files = os.listdir(os.curdir)
- files = filter(os.path.isdir, files)
- return self._filter(files, pat)
+ files = os.listdir(os.curdir)
+ files = filter(os.path.isdir, files)
+ return self._filter(files, pat)
def isdir(self, name):
- return os.path.isdir(name)
+ return os.path.isdir(name)
def mkdir(self, name):
- os.mkdir(name, 0777)
+ os.mkdir(name, 0777)
def rmdir(self, name):
- os.rmdir(name)
+ os.rmdir(name)
class RCSProxyLocal(rcslib.RCS, DirSupport):
def __init__(self):
- rcslib.RCS.__init__(self)
- DirSupport.__init__(self)
+ rcslib.RCS.__init__(self)
+ DirSupport.__init__(self)
def __del__(self):
- DirSupport.__del__(self)
- rcslib.RCS.__del__(self)
+ DirSupport.__del__(self)
+ rcslib.RCS.__del__(self)
def sumlist(self, list = None):
- return self._list(self.sum, list)
+ return self._list(self.sum, list)
def sumdict(self, list = None):
- return self._dict(self.sum, list)
+ return self._dict(self.sum, list)
def sum(self, name_rev):
- f = self._open(name_rev)
- BUFFERSIZE = 1024*8
- sum = md5.new()
- while 1:
- buffer = f.read(BUFFERSIZE)
- if not buffer:
- break
- sum.update(buffer)
- self._closepipe(f)
- return sum.digest()
+ f = self._open(name_rev)
+ BUFFERSIZE = 1024*8
+ sum = md5.new()
+ while 1:
+ buffer = f.read(BUFFERSIZE)
+ if not buffer:
+ break
+ sum.update(buffer)
+ self._closepipe(f)
+ return sum.digest()
def get(self, name_rev):
- f = self._open(name_rev)
- data = f.read()
- self._closepipe(f)
- return data
+ f = self._open(name_rev)
+ data = f.read()
+ self._closepipe(f)
+ return data
def put(self, name_rev, data, message=None):
- name, rev = self._unmangle(name_rev)
- f = open(name, 'w')
- f.write(data)
- f.close()
- self.checkin(name_rev, message)
- self._remove(name)
+ name, rev = self._unmangle(name_rev)
+ f = open(name, 'w')
+ f.write(data)
+ f.close()
+ self.checkin(name_rev, message)
+ self._remove(name)
def _list(self, function, list = None):
- """INTERNAL: apply FUNCTION to all files in LIST.
+ """INTERNAL: apply FUNCTION to all files in LIST.
- Return a list of the results.
+ Return a list of the results.
- The list defaults to all files in the directory if None.
+ The list defaults to all files in the directory if None.
- """
- if list is None:
- list = self.listfiles()
- res = []
- for name in list:
- try:
- res.append((name, function(name)))
- except (os.error, IOError):
- res.append((name, None))
- return res
+ """
+ if list is None:
+ list = self.listfiles()
+ res = []
+ for name in list:
+ try:
+ res.append((name, function(name)))
+ except (os.error, IOError):
+ res.append((name, None))
+ return res
def _dict(self, function, list = None):
- """INTERNAL: apply FUNCTION to all files in LIST.
+ """INTERNAL: apply FUNCTION to all files in LIST.
- Return a dictionary mapping files to results.
+ Return a dictionary mapping files to results.
- The list defaults to all files in the directory if None.
+ The list defaults to all files in the directory if None.
- """
- if list is None:
- list = self.listfiles()
- dict = {}
- for name in list:
- try:
- dict[name] = function(name)
- except (os.error, IOError):
- pass
- return dict
+ """
+ if list is None:
+ list = self.listfiles()
+ dict = {}
+ for name in list:
+ try:
+ dict[name] = function(name)
+ except (os.error, IOError):
+ pass
+ return dict
class RCSProxyServer(RCSProxyLocal, server.SecureServer):
def __init__(self, address, verbose = server.VERBOSE):
- RCSProxyLocal.__init__(self)
- server.SecureServer.__init__(self, address, verbose)
+ RCSProxyLocal.__init__(self)
+ server.SecureServer.__init__(self, address, verbose)
def _close(self):
- server.SecureServer._close(self)
- RCSProxyLocal._close(self)
+ server.SecureServer._close(self)
+ RCSProxyLocal._close(self)
def _serve(self):
- server.SecureServer._serve(self)
- # Retreat into start directory
- while self._dirstack: self.back()
+ server.SecureServer._serve(self)
+ # Retreat into start directory
+ while self._dirstack: self.back()
def test_server():
import string
import sys
if sys.argv[1:]:
- port = string.atoi(sys.argv[1])
+ port = string.atoi(sys.argv[1])
else:
- port = 4127
+ port = 4127
proxy = RCSProxyServer(('', port))
proxy._serverloop()
def test():
import sys
if not sys.argv[1:] or sys.argv[1] and sys.argv[1][0] in '0123456789':
- test_server()
- sys.exit(0)
+ test_server()
+ sys.exit(0)
proxy = RCSProxyLocal()
what = sys.argv[1]
if hasattr(proxy, what):
- attr = getattr(proxy, what)
- if callable(attr):
- print apply(attr, tuple(sys.argv[2:]))
- else:
- print `attr`
+ attr = getattr(proxy, what)
+ if callable(attr):
+ print apply(attr, tuple(sys.argv[2:]))
+ else:
+ print `attr`
else:
- print "%s: no such attribute" % what
- sys.exit(2)
+ print "%s: no such attribute" % what
+ sys.exit(2)
if __name__ == '__main__':
opts, args = getopt.getopt(args, 'p:')
prefix = ''
for o, a in opts:
- if p == '-p': prefix = a
+ if p == '-p': prefix = a
f = sys.stdin
allrevs = []
while 1:
- file = getnextfile(f)
- if not file: break
- revs = []
- while 1:
- rev = getnextrev(f, file)
- if not rev:
- break
- revs.append(rev)
- if revs:
- allrevs[len(allrevs):] = revs
+ file = getnextfile(f)
+ if not file: break
+ revs = []
+ while 1:
+ rev = getnextrev(f, file)
+ if not rev:
+ break
+ revs.append(rev)
+ if revs:
+ allrevs[len(allrevs):] = revs
allrevs.sort()
allrevs.reverse()
for rev in allrevs:
- formatrev(rev, prefix)
+ formatrev(rev, prefix)
parsedateprog = regex.compile(
'^date: \([0-9]+\)/\([0-9]+\)/\([0-9]+\) ' +
def formatrev(rev, prefix):
dateline, file, revline, log = rev
if parsedateprog.match(dateline) >= 0:
- fields = parsedateprog.group(1, 2, 3, 4, 5, 6)
- author = parsedateprog.group(7)
- if authormap.has_key(author): author = authormap[author]
- tfields = map(string.atoi, fields) + [0, 0, 0]
- tfields[5] = tfields[5] - time.timezone
- t = time.mktime(tuple(tfields))
- print time.ctime(t), '', author
- words = string.split(log)
- words[:0] = ['*', prefix + file + ':']
- maxcol = 72-8
- col = maxcol
- for word in words:
- if col > 0 and col + len(word) >= maxcol:
- print
- print '\t' + word,
- col = -1
- else:
- print word,
- col = col + 1 + len(word)
- print
- print
+ fields = parsedateprog.group(1, 2, 3, 4, 5, 6)
+ author = parsedateprog.group(7)
+ if authormap.has_key(author): author = authormap[author]
+ tfields = map(string.atoi, fields) + [0, 0, 0]
+ tfields[5] = tfields[5] - time.timezone
+ t = time.mktime(tuple(tfields))
+ print time.ctime(t), '', author
+ words = string.split(log)
+ words[:0] = ['*', prefix + file + ':']
+ maxcol = 72-8
+ col = maxcol
+ for word in words:
+ if col > 0 and col + len(word) >= maxcol:
+ print
+ print '\t' + word,
+ col = -1
+ else:
+ print word,
+ col = col + 1 + len(word)
+ print
+ print
startprog = regex.compile("^Working file: \(.*\)$")
def getnextfile(f):
while 1:
- line = f.readline()
- if not line: return None
- if startprog.match(line) >= 0:
- file = startprog.group(1)
- # Skip until first revision
- while 1:
- line = f.readline()
- if not line: return None
- if line[:10] == '='*10: return None
- if line[:10] == '-'*10: break
-## print "Skipped", line,
- return file
-## else:
-## print "Ignored", line,
+ line = f.readline()
+ if not line: return None
+ if startprog.match(line) >= 0:
+ file = startprog.group(1)
+ # Skip until first revision
+ while 1:
+ line = f.readline()
+ if not line: return None
+ if line[:10] == '='*10: return None
+ if line[:10] == '-'*10: break
+## print "Skipped", line,
+ return file
+## else:
+## print "Ignored", line,
def getnextrev(f, file):
# This is called when we are positioned just after a '---' separator
dateline = f.readline()
log = ''
while 1:
- line = f.readline()
- if not line: break
- if line[:10] == '='*10:
- # Ignore the *last* log entry for each file since it
- # is the revision since which we are logging.
- return None
- if line[:10] == '-'*10: break
- log = log + line
+ line = f.readline()
+ if not line: break
+ if line[:10] == '='*10:
+ # Ignore the *last* log entry for each file since it
+ # is the revision since which we are logging.
+ return None
+ if line[:10] == '-'*10: break
+ log = log + line
return dateline, file, revline, log
if __name__ == '__main__':
class RCSProxyClient(client.SecureClient):
- def __init__(self, address, verbose = client.VERBOSE):
- client.SecureClient.__init__(self, address, verbose)
+ def __init__(self, address, verbose = client.VERBOSE):
+ client.SecureClient.__init__(self, address, verbose)
def openrcsclient(opts = []):
okchars = string.letters + string.digits + '-_=+.'
def __init__(self):
- """Constructor."""
- pass
+ """Constructor."""
+ pass
def __del__(self):
- """Destructor."""
- pass
+ """Destructor."""
+ pass
# --- Informational methods about a single file/revision ---
def log(self, name_rev, otherflags = ''):
- """Return the full log text for NAME_REV as a string.
+ """Return the full log text for NAME_REV as a string.
- Optional OTHERFLAGS are passed to rlog.
+ Optional OTHERFLAGS are passed to rlog.
- """
- f = self._open(name_rev, 'rlog ' + otherflags)
- data = f.read()
- status = self._closepipe(f)
- if status:
- data = data + "%s: %s" % status
- elif data[-1] == '\n':
- data = data[:-1]
- return data
+ """
+ f = self._open(name_rev, 'rlog ' + otherflags)
+ data = f.read()
+ status = self._closepipe(f)
+ if status:
+ data = data + "%s: %s" % status
+ elif data[-1] == '\n':
+ data = data[:-1]
+ return data
def head(self, name_rev):
- """Return the head revision for NAME_REV"""
- dict = self.info(name_rev)
- return dict['head']
+ """Return the head revision for NAME_REV"""
+ dict = self.info(name_rev)
+ return dict['head']
def info(self, name_rev):
- """Return a dictionary of info (from rlog -h) for NAME_REV
-
- The dictionary's keys are the keywords that rlog prints
- (e.g. 'head' and its values are the corresponding data
- (e.g. '1.3').
-
- XXX symbolic names and locks are not returned
-
- """
- f = self._open(name_rev, 'rlog -h')
- dict = {}
- while 1:
- line = f.readline()
- if not line: break
- if line[0] == '\t':
- # XXX could be a lock or symbolic name
- # Anything else?
- continue
- i = string.find(line, ':')
- if i > 0:
- key, value = line[:i], string.strip(line[i+1:])
- dict[key] = value
- status = self._closepipe(f)
- if status:
- raise IOError, status
- return dict
+ """Return a dictionary of info (from rlog -h) for NAME_REV
+
+ The dictionary's keys are the keywords that rlog prints
+ (e.g. 'head' and its values are the corresponding data
+ (e.g. '1.3').
+
+ XXX symbolic names and locks are not returned
+
+ """
+ f = self._open(name_rev, 'rlog -h')
+ dict = {}
+ while 1:
+ line = f.readline()
+ if not line: break
+ if line[0] == '\t':
+ # XXX could be a lock or symbolic name
+ # Anything else?
+ continue
+ i = string.find(line, ':')
+ if i > 0:
+ key, value = line[:i], string.strip(line[i+1:])
+ dict[key] = value
+ status = self._closepipe(f)
+ if status:
+ raise IOError, status
+ return dict
# --- Methods that change files ---
def lock(self, name_rev):
- """Set an rcs lock on NAME_REV."""
- name, rev = self.checkfile(name_rev)
- cmd = "rcs -l%s %s" % (rev, name)
- return self._system(cmd)
+ """Set an rcs lock on NAME_REV."""
+ name, rev = self.checkfile(name_rev)
+ cmd = "rcs -l%s %s" % (rev, name)
+ return self._system(cmd)
def unlock(self, name_rev):
- """Clear an rcs lock on NAME_REV."""
- name, rev = self.checkfile(name_rev)
- cmd = "rcs -u%s %s" % (rev, name)
- return self._system(cmd)
+ """Clear an rcs lock on NAME_REV."""
+ name, rev = self.checkfile(name_rev)
+ cmd = "rcs -u%s %s" % (rev, name)
+ return self._system(cmd)
def checkout(self, name_rev, withlock=0, otherflags=""):
- """Check out NAME_REV to its work file.
+ """Check out NAME_REV to its work file.
- If optional WITHLOCK is set, check out locked, else unlocked.
+ If optional WITHLOCK is set, check out locked, else unlocked.
- The optional OTHERFLAGS is passed to co without
- interpretation.
+ The optional OTHERFLAGS is passed to co without
+ interpretation.
- Any output from co goes to directly to stdout.
+ Any output from co goes to directly to stdout.
- """
- name, rev = self.checkfile(name_rev)
- if withlock: lockflag = "-l"
- else: lockflag = "-u"
- cmd = 'co %s%s %s %s' % (lockflag, rev, otherflags, name)
- return self._system(cmd)
+ """
+ name, rev = self.checkfile(name_rev)
+ if withlock: lockflag = "-l"
+ else: lockflag = "-u"
+ cmd = 'co %s%s %s %s' % (lockflag, rev, otherflags, name)
+ return self._system(cmd)
def checkin(self, name_rev, message=None, otherflags=""):
- """Check in NAME_REV from its work file.
-
- The optional MESSAGE argument becomes the checkin message
- (default "<none>" if None); or the file description if this is
- a new file.
-
- The optional OTHERFLAGS argument is passed to ci without
- interpretation.
-
- Any output from ci goes to directly to stdout.
-
- """
- name, rev = self._unmangle(name_rev)
- new = not self.isvalid(name)
- if not message: message = "<none>"
- if message and message[-1] != '\n':
- message = message + '\n'
- lockflag = "-u"
- textfile = None
- try:
- if new:
- textfile = tempfile.mktemp()
- f = open(textfile, 'w')
- f.write(message)
- f.close()
- cmd = 'ci %s%s -t%s %s %s' % \
- (lockflag, rev, textfile, otherflags, name)
- else:
- message = regsub.gsub('\([\\"$`]\)', '\\\\\\1', message)
- cmd = 'ci %s%s -m"%s" %s %s' % \
- (lockflag, rev, message, otherflags, name)
- return self._system(cmd)
- finally:
- if textfile: self._remove(textfile)
+ """Check in NAME_REV from its work file.
+
+ The optional MESSAGE argument becomes the checkin message
+ (default "<none>" if None); or the file description if this is
+ a new file.
+
+ The optional OTHERFLAGS argument is passed to ci without
+ interpretation.
+
+ Any output from ci goes to directly to stdout.
+
+ """
+ name, rev = self._unmangle(name_rev)
+ new = not self.isvalid(name)
+ if not message: message = "<none>"
+ if message and message[-1] != '\n':
+ message = message + '\n'
+ lockflag = "-u"
+ textfile = None
+ try:
+ if new:
+ textfile = tempfile.mktemp()
+ f = open(textfile, 'w')
+ f.write(message)
+ f.close()
+ cmd = 'ci %s%s -t%s %s %s' % \
+ (lockflag, rev, textfile, otherflags, name)
+ else:
+ message = regsub.gsub('\([\\"$`]\)', '\\\\\\1', message)
+ cmd = 'ci %s%s -m"%s" %s %s' % \
+ (lockflag, rev, message, otherflags, name)
+ return self._system(cmd)
+ finally:
+ if textfile: self._remove(textfile)
# --- Exported support methods ---
def listfiles(self, pat = None):
- """Return a list of all version files matching optional PATTERN."""
- files = os.listdir(os.curdir)
- files = filter(self._isrcs, files)
- if os.path.isdir('RCS'):
- files2 = os.listdir('RCS')
- files2 = filter(self._isrcs, files2)
- files = files + files2
- files = map(self.realname, files)
- return self._filter(files, pat)
+ """Return a list of all version files matching optional PATTERN."""
+ files = os.listdir(os.curdir)
+ files = filter(self._isrcs, files)
+ if os.path.isdir('RCS'):
+ files2 = os.listdir('RCS')
+ files2 = filter(self._isrcs, files2)
+ files = files + files2
+ files = map(self.realname, files)
+ return self._filter(files, pat)
def isvalid(self, name):
- """Test whether NAME has a version file associated."""
- namev = self.rcsname(name)
- return (os.path.isfile(namev) or
- os.path.isfile(os.path.join('RCS', namev)))
+ """Test whether NAME has a version file associated."""
+ namev = self.rcsname(name)
+ return (os.path.isfile(namev) or
+ os.path.isfile(os.path.join('RCS', namev)))
def rcsname(self, name):
- """Return the pathname of the version file for NAME.
-
- The argument can be a work file name or a version file name.
- If the version file does not exist, the name of the version
- file that would be created by "ci" is returned.
-
- """
- if self._isrcs(name): namev = name
- else: namev = name + ',v'
- if os.path.isfile(namev): return namev
- namev = os.path.join('RCS', os.path.basename(namev))
- if os.path.isfile(namev): return namev
- if os.path.isdir('RCS'):
- return os.path.join('RCS', namev)
- else:
- return namev
+ """Return the pathname of the version file for NAME.
+
+ The argument can be a work file name or a version file name.
+ If the version file does not exist, the name of the version
+ file that would be created by "ci" is returned.
+
+ """
+ if self._isrcs(name): namev = name
+ else: namev = name + ',v'
+ if os.path.isfile(namev): return namev
+ namev = os.path.join('RCS', os.path.basename(namev))
+ if os.path.isfile(namev): return namev
+ if os.path.isdir('RCS'):
+ return os.path.join('RCS', namev)
+ else:
+ return namev
def realname(self, namev):
- """Return the pathname of the work file for NAME.
+ """Return the pathname of the work file for NAME.
- The argument can be a work file name or a version file name.
- If the work file does not exist, the name of the work file
- that would be created by "co" is returned.
+ The argument can be a work file name or a version file name.
+ If the work file does not exist, the name of the work file
+ that would be created by "co" is returned.
- """
- if self._isrcs(namev): name = namev[:-2]
- else: name = namev
- if os.path.isfile(name): return name
- name = os.path.basename(name)
- return name
+ """
+ if self._isrcs(namev): name = namev[:-2]
+ else: name = namev
+ if os.path.isfile(name): return name
+ name = os.path.basename(name)
+ return name
def islocked(self, name_rev):
- """Test whether FILE (which must have a version file) is locked.
-
- XXX This does not tell you which revision number is locked and
- ignores any revision you may pass in (by virtue of using rlog
- -L -R).
-
- """
- f = self._open(name_rev, 'rlog -L -R')
- line = f.readline()
- status = self._closepipe(f)
- if status:
- raise IOError, status
- if not line: return None
- if line[-1] == '\n':
- line = line[:-1]
- return self.realname(name_rev) == self.realname(line)
+ """Test whether FILE (which must have a version file) is locked.
+
+ XXX This does not tell you which revision number is locked and
+ ignores any revision you may pass in (by virtue of using rlog
+ -L -R).
+
+ """
+ f = self._open(name_rev, 'rlog -L -R')
+ line = f.readline()
+ status = self._closepipe(f)
+ if status:
+ raise IOError, status
+ if not line: return None
+ if line[-1] == '\n':
+ line = line[:-1]
+ return self.realname(name_rev) == self.realname(line)
def checkfile(self, name_rev):
- """Normalize NAME_REV into a (NAME, REV) tuple.
+ """Normalize NAME_REV into a (NAME, REV) tuple.
- Raise an exception if there is no corresponding version file.
+ Raise an exception if there is no corresponding version file.
- """
- name, rev = self._unmangle(name_rev)
- if not self.isvalid(name):
- raise os.error, 'not an rcs file %s' % `name`
- return name, rev
+ """
+ name, rev = self._unmangle(name_rev)
+ if not self.isvalid(name):
+ raise os.error, 'not an rcs file %s' % `name`
+ return name, rev
# --- Internal methods ---
def _open(self, name_rev, cmd = 'co -p', rflag = '-r'):
- """INTERNAL: open a read pipe to NAME_REV using optional COMMAND.
+ """INTERNAL: open a read pipe to NAME_REV using optional COMMAND.
- Optional FLAG is used to indicate the revision (default -r).
+ Optional FLAG is used to indicate the revision (default -r).
- Default COMMAND is "co -p".
+ Default COMMAND is "co -p".
- Return a file object connected by a pipe to the command's
- output.
+ Return a file object connected by a pipe to the command's
+ output.
- """
- name, rev = self.checkfile(name_rev)
- namev = self.rcsname(name)
- if rev:
- cmd = cmd + ' ' + rflag + rev
- return os.popen("%s %s" % (cmd, `namev`))
+ """
+ name, rev = self.checkfile(name_rev)
+ namev = self.rcsname(name)
+ if rev:
+ cmd = cmd + ' ' + rflag + rev
+ return os.popen("%s %s" % (cmd, `namev`))
def _unmangle(self, name_rev):
- """INTERNAL: Normalize NAME_REV argument to (NAME, REV) tuple.
+ """INTERNAL: Normalize NAME_REV argument to (NAME, REV) tuple.
- Raise an exception if NAME contains invalid characters.
+ Raise an exception if NAME contains invalid characters.
- A NAME_REV argument is either NAME string (implying REV='') or
- a tuple of the form (NAME, REV).
+ A NAME_REV argument is either NAME string (implying REV='') or
+ a tuple of the form (NAME, REV).
- """
- if type(name_rev) == type(''):
- name_rev = name, rev = name_rev, ''
- else:
- name, rev = name_rev
- for c in rev:
- if c not in self.okchars:
- raise ValueError, "bad char in rev"
- return name_rev
+ """
+ if type(name_rev) == type(''):
+ name_rev = name, rev = name_rev, ''
+ else:
+ name, rev = name_rev
+ for c in rev:
+ if c not in self.okchars:
+ raise ValueError, "bad char in rev"
+ return name_rev
def _closepipe(self, f):
- """INTERNAL: Close PIPE and print its exit status if nonzero."""
- sts = f.close()
- if not sts: return None
- detail, reason = divmod(sts, 256)
- if reason == 0: return 'exit', detail # Exit status
- signal = reason&0x7F
- if signal == 0x7F:
- code = 'stopped'
- signal = detail
- else:
- code = 'killed'
- if reason&0x80:
- code = code + '(coredump)'
- return code, signal
+ """INTERNAL: Close PIPE and print its exit status if nonzero."""
+ sts = f.close()
+ if not sts: return None
+ detail, reason = divmod(sts, 256)
+ if reason == 0: return 'exit', detail # Exit status
+ signal = reason&0x7F
+ if signal == 0x7F:
+ code = 'stopped'
+ signal = detail
+ else:
+ code = 'killed'
+ if reason&0x80:
+ code = code + '(coredump)'
+ return code, signal
def _system(self, cmd):
- """INTERNAL: run COMMAND in a subshell.
+ """INTERNAL: run COMMAND in a subshell.
- Standard input for the command is taken fron /dev/null.
+ Standard input for the command is taken fron /dev/null.
- Raise IOError when the exit status is not zero.
+ Raise IOError when the exit status is not zero.
- Return whatever the calling method should return; normally
- None.
+ Return whatever the calling method should return; normally
+ None.
- A derived class may override this method and redefine it to
- capture stdout/stderr of the command and return it.
+ A derived class may override this method and redefine it to
+ capture stdout/stderr of the command and return it.
- """
- cmd = cmd + " </dev/null"
- sts = os.system(cmd)
- if sts: raise IOError, "command exit status %d" % sts
+ """
+ cmd = cmd + " </dev/null"
+ sts = os.system(cmd)
+ if sts: raise IOError, "command exit status %d" % sts
def _filter(self, files, pat = None):
- """INTERNAL: Return a sorted copy of the given list of FILES.
-
- If a second PATTERN argument is given, only files matching it
- are kept. No check for valid filenames is made.
-
- """
- if pat:
- def keep(name, pat = pat):
- return fnmatch.fnmatch(name, pat)
- files = filter(keep, files)
- else:
- files = files[:]
- files.sort()
- return files
+ """INTERNAL: Return a sorted copy of the given list of FILES.
+
+ If a second PATTERN argument is given, only files matching it
+ are kept. No check for valid filenames is made.
+
+ """
+ if pat:
+ def keep(name, pat = pat):
+ return fnmatch.fnmatch(name, pat)
+ files = filter(keep, files)
+ else:
+ files = files[:]
+ files.sort()
+ return files
def _remove(self, fn):
- """INTERNAL: remove FILE without complaints."""
- try:
- os.unlink(fn)
- except os.error:
- pass
+ """INTERNAL: remove FILE without complaints."""
+ try:
+ os.unlink(fn)
+ except os.error:
+ pass
def _isrcs(self, name):
- """INTERNAL: Test whether NAME ends in ',v'."""
- return name[-2:] == ',v'
+ """INTERNAL: Test whether NAME ends in ',v'."""
+ return name[-2:] == ',v'
import sys, os, string, getopt, thread, socket, traceback
-PORT = 4000 # Default port
+PORT = 4000 # Default port
def main():
try:
- opts, args = getopt.getopt(sys.argv[1:], "")
- if len(args) > 1:
- raise getopt.error, "Too many arguments."
+ opts, args = getopt.getopt(sys.argv[1:], "")
+ if len(args) > 1:
+ raise getopt.error, "Too many arguments."
except getopt.error, msg:
- usage(msg)
+ usage(msg)
for o, a in opts:
- pass
+ pass
if args:
- try:
- port = string.atoi(args[0])
- except ValueError, msg:
- usage(msg)
+ try:
+ port = string.atoi(args[0])
+ except ValueError, msg:
+ usage(msg)
else:
- port = PORT
+ port = PORT
main_thread(port)
def usage(msg=None):
sys.stdout = sys.stderr
if msg:
- print msg
+ print msg
print "\n", __doc__,
sys.exit(2)
sock.listen(5)
print "Listening on port", port, "..."
while 1:
- (conn, addr) = sock.accept()
- if addr[0] != conn.getsockname()[0]:
- conn.close()
- print "Refusing connection from non-local host", addr[0], "."
- continue
- thread.start_new_thread(service_thread, (conn, addr))
- del conn, addr
+ (conn, addr) = sock.accept()
+ if addr[0] != conn.getsockname()[0]:
+ conn.close()
+ print "Refusing connection from non-local host", addr[0], "."
+ continue
+ thread.start_new_thread(service_thread, (conn, addr))
+ del conn, addr
def service_thread(conn, addr):
(caddr, cport) = addr
print "Thread %s has connection from %s.\n" % (str(thread.get_ident()),
- caddr),
+ caddr),
stdin = conn.makefile("r")
stdout = conn.makefile("w", 0)
run_interpreter(stdin, stdout)
def run_interpreter(stdin, stdout):
globals = {}
try:
- str(sys.ps1)
+ str(sys.ps1)
except:
- sys.ps1 = ">>> "
+ sys.ps1 = ">>> "
source = ""
while 1:
- stdout.write(sys.ps1)
- line = stdin.readline()
- if line[:2] == '\377\354':
- line = ""
- if not line and not source:
- break
- if line[-2:] == '\r\n':
- line = line[:-2] + '\n'
- source = source + line
- try:
- code = compile_command(source)
- except SyntaxError, err:
- source = ""
- traceback.print_exception(SyntaxError, err, None, file=stdout)
- continue
- if not code:
- continue
- source = ""
- try:
- run_command(code, stdin, stdout, globals)
- except SystemExit, how:
- if how:
- try:
- how = str(how)
- except:
- how = ""
- stdout.write("Exit %s\n" % how)
- break
+ stdout.write(sys.ps1)
+ line = stdin.readline()
+ if line[:2] == '\377\354':
+ line = ""
+ if not line and not source:
+ break
+ if line[-2:] == '\r\n':
+ line = line[:-2] + '\n'
+ source = source + line
+ try:
+ code = compile_command(source)
+ except SyntaxError, err:
+ source = ""
+ traceback.print_exception(SyntaxError, err, None, file=stdout)
+ continue
+ if not code:
+ continue
+ source = ""
+ try:
+ run_command(code, stdin, stdout, globals)
+ except SystemExit, how:
+ if how:
+ try:
+ how = str(how)
+ except:
+ how = ""
+ stdout.write("Exit %s\n" % how)
+ break
stdout.write("\nGoodbye.\n")
def run_command(code, stdin, stdout, globals):
- save = sys.stdin, sys.stdout, sys.stderr
- try:
- sys.stdout = sys.stderr = stdout
- sys.stdin = stdin
- try:
- exec code in globals
- except SystemExit, how:
- raise SystemExit, how, sys.exc_info()[2]
- except:
- type, value, tb = sys.exc_info()
- if tb: tb = tb.tb_next
- traceback.print_exception(type, value, tb)
- del tb
- finally:
- sys.stdin, sys.stdout, sys.stderr = save
+ save = sys.stdin, sys.stdout, sys.stderr
+ try:
+ sys.stdout = sys.stderr = stdout
+ sys.stdin = stdin
+ try:
+ exec code in globals
+ except SystemExit, how:
+ raise SystemExit, how, sys.exc_info()[2]
+ except:
+ type, value, tb = sys.exc_info()
+ if tb: tb = tb.tb_next
+ traceback.print_exception(type, value, tb)
+ del tb
+ finally:
+ sys.stdin, sys.stdout, sys.stderr = save
from code import compile_command
return status, attributes
def unpack_fattr(self):
- type = self.unpack_enum()
- mode = self.unpack_uint()
- nlink = self.unpack_uint()
- uid = self.unpack_uint()
- gid = self.unpack_uint()
- size = self.unpack_uint()
- blocksize = self.unpack_uint()
- rdev = self.unpack_uint()
- blocks = self.unpack_uint()
- fsid = self.unpack_uint()
- fileid = self.unpack_uint()
- atime = self.unpack_timeval()
- mtime = self.unpack_timeval()
- ctime = self.unpack_timeval()
- return (type, mode, nlink, uid, gid, size, blocksize, \
- rdev, blocks, fsid, fileid, atime, mtime, ctime)
+ type = self.unpack_enum()
+ mode = self.unpack_uint()
+ nlink = self.unpack_uint()
+ uid = self.unpack_uint()
+ gid = self.unpack_uint()
+ size = self.unpack_uint()
+ blocksize = self.unpack_uint()
+ rdev = self.unpack_uint()
+ blocks = self.unpack_uint()
+ fsid = self.unpack_uint()
+ fileid = self.unpack_uint()
+ atime = self.unpack_timeval()
+ mtime = self.unpack_timeval()
+ ctime = self.unpack_timeval()
+ return (type, mode, nlink, uid, gid, size, blocksize, \
+ rdev, blocks, fsid, fileid, atime, mtime, ctime)
def unpack_timeval(self):
secs = self.unpack_uint()
bytype = {}
lineno = 0
try:
- while 1:
- line = f.readline()
- if not line: break
- lineno = lineno + 1
- if search and string.find(line, search) < 0:
- continue
- if prog.match(line) < 0:
- print 'Bad line', lineno, ':', `line`
- continue
- items = prog.group(1, 2, 3, 4, 5, 6)
- logtime, loguser, loghost, logfile, logbytes, logxxx2 = items
-## print logtime
-## print '-->', loguser
-## print '--> -->', loghost
-## print '--> --> -->', logfile
-## print '--> --> --> -->', logbytes
-## print '--> --> --> --> -->', logxxx2
-## for i in logtime, loghost, logbytes, logxxx2:
-## if '!' in i: print '???', i
- add(bydate, logtime[-4:] + ' ' + logtime[:6], items)
- add(bytime, logtime[7:9] + ':00-59', items)
- direction, logfile = logfile[0], logfile[1:]
- # The real path probably starts at the last //...
while 1:
- i = string.find(logfile, '//')
- if i < 0: break
- logfile = logfile[i+1:]
- add(byfile, logfile + ' ' + direction, items)
- logdir = os.path.dirname(logfile)
+ line = f.readline()
+ if not line: break
+ lineno = lineno + 1
+ if search and string.find(line, search) < 0:
+ continue
+ if prog.match(line) < 0:
+ print 'Bad line', lineno, ':', `line`
+ continue
+ items = prog.group(1, 2, 3, 4, 5, 6)
+ (logtime, loguser, loghost, logfile, logbytes,
+ logxxx2) = items
+## print logtime
+## print '-->', loguser
+## print '--> -->', loghost
+## print '--> --> -->', logfile
+## print '--> --> --> -->', logbytes
+## print '--> --> --> --> -->', logxxx2
+## for i in logtime, loghost, logbytes, logxxx2:
+## if '!' in i: print '???', i
+ add(bydate, logtime[-4:] + ' ' + logtime[:6], items)
+ add(bytime, logtime[7:9] + ':00-59', items)
+ direction, logfile = logfile[0], logfile[1:]
+ # The real path probably starts at the last //...
+ while 1:
+ i = string.find(logfile, '//')
+ if i < 0: break
+ logfile = logfile[i+1:]
+ add(byfile, logfile + ' ' + direction, items)
+ logdir = os.path.dirname(logfile)
## logdir = os.path.normpath(logdir) + '/.'
- while 1:
- add(bydir, logdir + ' ' + direction, items)
- dirhead = os.path.dirname(logdir)
- if dirhead == logdir: break
- logdir = dirhead
- add(byhost, loghost, items)
- add(byuser, loguser, items)
- add(bytype, direction, items)
+ while 1:
+ add(bydir, logdir + ' ' + direction, items)
+ dirhead = os.path.dirname(logdir)
+ if dirhead == logdir: break
+ logdir = dirhead
+ add(byhost, loghost, items)
+ add(byuser, loguser, items)
+ add(bytype, direction, items)
except KeyboardInterrupt:
print 'Interrupted at line', lineno
show(bytype, 'by transfer direction', maxitems)
#######################################################################
for dir in os.curdir, os.environ['HOME']:
- rcfile = os.path.join(dir, '.newslistrc.py')
- if os.path.exists(rcfile):
- print rcfile
- execfile(rcfile)
- break
+ rcfile = os.path.join(dir, '.newslistrc.py')
+ if os.path.exists(rcfile):
+ print rcfile
+ execfile(rcfile)
+ break
from nntplib import NNTP
from stat import *
def addtotree(tree, groups):
print 'Updating tree...'
for i in groups:
- parts = string.splitfields(i,'.')
- makeleaf(tree, parts)
+ parts = string.splitfields(i,'.')
+ makeleaf(tree, parts)
# Makeleaf makes a leaf and the branch leading to it if necessary
def makeleaf(tree,path):
if l > 1:
makeleaf(tree[j],path[1:])
-# Then the bits for outputting trees as pages ----------------
+# Then the bits for outputting trees as pages ----------------
# Createpage creates an HTML file named <root>.html containing links
# to those groups beginning with <root>.
if l > 1:
kl.sort()
if indent > 0:
- # Create a sub-list
- f.write('<LI>'+p[1:]+'\n<UL>')
+ # Create a sub-list
+
f.write('<LI>'+p[1:]+'\n<UL>')
else:
- # Create a main list
- f.write('<UL>')
+ # Create a main list
indent = indent + 1
for i in kl:
if i == '.':
- # Output a newsgroup
- f.write('<LI><A HREF="news:' + p[1:] + '">'+ p[1:] + '</A> ')
- if desc.has_key(p[1:]):
- f.write(' <I>'+desc[p[1:]]+'</I>\n')
- else:
- f.write('\n')
+ # Output a newsgroup
+
f.write('<LI><A HREF="news:' + p[1:] + '">'+ p[1:] + '</A> ')
+ if desc.has_key(p[1:]):
+ f.write(' <I>'+desc[p[1:]]+'</I>\n')
+ else:
+ f.write('\n')
else:
- # Output a hierarchy
- printtree(f,tree[i], indent, p+'.'+i)
+ # Output a hierarchy
+ printtree(f,tree[i], indent, p+'.'+i)
if l > 1:
f.write('\n</UL>')
desc = {}
if descfile == '':
- return
+ return
try:
d = open(descfile, 'r')
while l != '':
bits = string.split(l)
try:
- grp = bits[0]
- dsc = string.join(bits[1:])
- if len(dsc)>1:
- desc[grp] = dsc
+ grp = bits[0]
+ dsc = string.join(bits[1:])
+ if len(dsc)>1:
+ desc[grp] = dsc
except (IndexError):
- pass
+ pass
l = d.readline()
# Check that ouput directory exists, ------------------------------
print 'Directory '+pagedir+' does not exist.'
print 'Shall I create it for you? (y/n)'
if sys.stdin.readline()[0] == 'y':
- try:
- os.mkdir(pagedir,0777)
- except:
- print 'Sorry - failed!'
- sys.exit(1)
+ try:
+ os.mkdir(pagedir,0777)
+ except:
+ print 'Sorry - failed!'
+ sys.exit(1)
else:
- print 'OK. Exiting.'
- sys.exit(1)
+ print 'OK. Exiting.'
+ sys.exit(1)
# Read and write current local tree ----------------------------------
print 'Reading current local group list...'
tree = {}
try:
- treetime = time.localtime(os.stat(treefile)[ST_MTIME])
+ treetime = time.localtime(os.stat(treefile)[ST_MTIME])
except:
- print '\n*** Failed to open local group cache '+treefile
- print 'If this is the first time you have run newslist, then'
- print 'use the -a option to create it.'
- sys.exit(1)
+ print '\n*** Failed to open local group cache '+treefile
+ print 'If this is the first time you have run newslist, then'
+ print 'use the -a option to create it.'
+ sys.exit(1)
treedate = '%02d%02d%02d' % (treetime[0] % 100 ,treetime[1], treetime[2])
try:
- dump = open(treefile,'r')
- tree = marshal.load(dump)
- dump.close()
+ dump = open(treefile,'r')
+ tree = marshal.load(dump)
+ dump.close()
except (IOError):
- print 'Cannot open local group list ' + treefile
+ print 'Cannot open local group list ' + treefile
return (tree, treedate)
def writelocallist(treefile, tree):
for i in info:
grpname = string.split(i[0])[0]
if skipempty and string.atoi(i[1]) < string.atoi(i[2]):
- print grpname+' ',
+ print grpname+' ',
else:
- groups.append(grpname)
+ groups.append(grpname)
print '\n'
if skipempty:
print '(End of empty groups)'
try:
print 'Connecting to '+newshost+'...'
if sys.version[0] == '0':
- s = NNTP.init(newshost)
+ s = NNTP.init(newshost)
else:
- s = NNTP(newshost)
+ s = NNTP(newshost)
connected = 1
except (nntplib.error_temp, nntplib.error_perm), x:
print 'Error connecting to host:', x
(tree, treedate) = readlocallist(treefile)
if connected:
- groups = getnewgroups(s, treedate)
+ groups = getnewgroups(s, treedate)
if connected:
addtotree(tree, groups)
commands['\t'] = WC_TAB
#
def getevent():
- while 1:
- #
- # Get next event from the processed queue, if any
- #
- if G.queue:
- event = G.queue[0]
- del G.queue[0]
- #print 'getevent from queue -->', event
- return event
- #
- # Get next event from the draw queue, if any,
- # but only if there is nothing in the system queue.
- #
- if G.drawqueue and not gl.qtest():
- win = G.drawqueue[0]
- del G.drawqueue[0]
- gl.winset(win._gid)
- gl.color(win._bg)
- gl.clear()
- event = WE_DRAW, win, win._area
- #print 'getevent from drawqueue -->', event
- return event
- #
- # Get next event from system queue, blocking if necessary
- # until one is available.
- # Some cases immediately return the event, others do nothing
- # or append one or more events to the processed queue.
- #
- dev, val = gl.qread()
- #
- if dev == REDRAW:
- win = G.windowmap[`val`]
- old_area = win._area
- win._fixviewport()
- win._needredraw()
- if old_area <> win._area:
- #print 'getevent --> WE_SIZE'
- return WE_SIZE, win, None
- elif dev == KEYBD:
- if val == 3:
- raise KeyboardInterrupt # Control-C in window
- character = chr(val)
- if commands.has_key(character):
- return WE_COMMAND, G.focus, commands[character]
- return WE_CHAR, G.focus, character
- elif dev == LEFTARROWKEY:
- if val:
- return WE_COMMAND, G.focus, WC_LEFT
- elif dev == RIGHTARROWKEY:
- if val:
- return WE_COMMAND, G.focus, WC_RIGHT
- elif dev == UPARROWKEY:
- if val:
- return WE_COMMAND, G.focus, WC_UP
- elif dev == DOWNARROWKEY:
- if val:
- return WE_COMMAND, G.focus, WC_DOWN
- elif dev in (LEFTALTKEY, RIGHTALTKEY):
- if val:
- for code in codelist:
- gl.qdevice(code)
+ while 1:
+ #
+ # Get next event from the processed queue, if any
+ #
+ if G.queue:
+ event = G.queue[0]
+ del G.queue[0]
+ #print 'getevent from queue -->', event
+ return event
+ #
+ # Get next event from the draw queue, if any,
+ # but only if there is nothing in the system queue.
+ #
+ if G.drawqueue and not gl.qtest():
+ win = G.drawqueue[0]
+ del G.drawqueue[0]
+ gl.winset(win._gid)
+ gl.color(win._bg)
+ gl.clear()
+ event = WE_DRAW, win, win._area
+ #print 'getevent from drawqueue -->', event
+ return event
+ #
+ # Get next event from system queue, blocking if necessary
+ # until one is available.
+ # Some cases immediately return the event, others do nothing
+ # or append one or more events to the processed queue.
+ #
+ dev, val = gl.qread()
+ #
+ if dev == REDRAW:
+ win = G.windowmap[`val`]
+ old_area = win._area
+ win._fixviewport()
+ win._needredraw()
+ if old_area <> win._area:
+ #print 'getevent --> WE_SIZE'
+ return WE_SIZE, win, None
+ elif dev == KEYBD:
+ if val == 3:
+ raise KeyboardInterrupt # Control-C in window
+ character = chr(val)
+ if commands.has_key(character):
+ return WE_COMMAND, G.focus, commands[character]
+ return WE_CHAR, G.focus, character
+ elif dev == LEFTARROWKEY:
+ if val:
+ return WE_COMMAND, G.focus, WC_LEFT
+ elif dev == RIGHTARROWKEY:
+ if val:
+ return WE_COMMAND, G.focus, WC_RIGHT
+ elif dev == UPARROWKEY:
+ if val:
+ return WE_COMMAND, G.focus, WC_UP
+ elif dev == DOWNARROWKEY:
+ if val:
+ return WE_COMMAND, G.focus, WC_DOWN
+ elif dev in (LEFTALTKEY, RIGHTALTKEY):
+ if val:
+ for code in codelist:
+ gl.qdevice(code)
+ else:
+ for code in codelist:
+ gl.unqdevice(code)
+ elif dev in codelist:
+ if val:
+ event = G.focus._doshortcut(code2key[`dev`])
+ if event:
+ return event
+ elif dev == LEFTMOUSE:
+ G.mousex = gl.getvaluator(MOUSEX)
+ G.mousey = gl.getvaluator(MOUSEY)
+ if val:
+ type = WE_MOUSE_DOWN
+ gl.qdevice(MOUSEX)
+ gl.qdevice(MOUSEY)
+ else:
+ type = WE_MOUSE_UP
+ gl.unqdevice(MOUSEX)
+ gl.unqdevice(MOUSEY)
+ return _mouseevent(type)
+ elif dev == MOUSEX:
+ G.mousex = val
+ return _mouseevent(WE_MOUSE_MOVE)
+ elif dev == MOUSEY:
+ G.mousey = val
+ return _mouseevent(WE_MOUSE_MOVE)
+ elif dev == RIGHTMOUSE: # Menu button press/release
+ if val: # Press
+ event = G.focus._domenu()
+ if event:
+ return event
+ elif dev == INPUTCHANGE:
+ if G.focus:
+ G.queue.append(WE_DEACTIVATE, G.focus, None)
+ G.focus = G.windowmap[`val`]
+ if G.focus:
+ G.queue.append(WE_ACTIVATE, G.focus, None)
+ elif dev in (WINSHUT, WINQUIT):
+ return WE_CLOSE, G.windowmap[`val`], None
else:
- for code in codelist:
- gl.unqdevice(code)
- elif dev in codelist:
- if val:
- event = G.focus._doshortcut(code2key[`dev`])
- if event:
- return event
- elif dev == LEFTMOUSE:
- G.mousex = gl.getvaluator(MOUSEX)
- G.mousey = gl.getvaluator(MOUSEY)
- if val:
- type = WE_MOUSE_DOWN
- gl.qdevice(MOUSEX)
- gl.qdevice(MOUSEY)
- else:
- type = WE_MOUSE_UP
- gl.unqdevice(MOUSEX)
- gl.unqdevice(MOUSEY)
- return _mouseevent(type)
- elif dev == MOUSEX:
- G.mousex = val
- return _mouseevent(WE_MOUSE_MOVE)
- elif dev == MOUSEY:
- G.mousey = val
- return _mouseevent(WE_MOUSE_MOVE)
- elif dev == RIGHTMOUSE: # Menu button press/release
- if val: # Press
- event = G.focus._domenu()
- if event:
- return event
- elif dev == INPUTCHANGE:
- if G.focus:
- G.queue.append(WE_DEACTIVATE, G.focus, None)
- G.focus = G.windowmap[`val`]
- if G.focus:
- G.queue.append(WE_ACTIVATE, G.focus, None)
- elif dev in (WINSHUT, WINQUIT):
- return WE_CLOSE, G.windowmap[`val`], None
- else:
- print '*** qread() --> dev:', dev, 'val:', val
+ print '*** qread() --> dev:', dev, 'val:', val
# Helper routine to construct a mouse (up, move or down) event
#
# Make a cylinder paralel with the Z axis with center (X,Y,0)
# and radius 1
def mkcyl(nslice, nparts, docircle):
- cyl = []
- step = 2.0 / float(nslice)
- z = -1.0
- for i in range(nslice):
- cyl.append(mkslice(z, z+step, nparts, docircle))
- z = z + step
- return drawcylinder(cyl)
+ cyl = []
+ step = 2.0 / float(nslice)
+ z = -1.0
+ for i in range(nslice):
+ cyl.append(mkslice(z, z+step, nparts, docircle))
+ z = z + step
+ return drawcylinder(cyl)
#
# Make one part of a cylinder
#
def mkslice(z1, z2, nparts, docircle):
- if docircle:
- w1 = z1
- w2 = z2
- w1 = sqrt(1.0-w1*w1)
- w2 = sqrt(1.0-w2*w2)
- normalz = 1.0
- else:
- w1 = 1.0
- w2 = 1.0
- normalz = 0.0
- slice = []
- step = (2.0*pi)/float(nparts)
- angle = 0.0
- for i in range(nparts+1):
- vx = cos(angle)
- vy = sin(angle)
- slice.append( ((vx*w1,vy*w1,z1), (vx*w1, vy*w1, z1*normalz)) )
- slice.append( ((vx*w2,vy*w2,z2), (vx*w2, vy*w2, z2*normalz)) )
- angle = angle + step
- return slice
+ if docircle:
+ w1 = z1
+ w2 = z2
+ w1 = sqrt(1.0-w1*w1)
+ w2 = sqrt(1.0-w2*w2)
+ normalz = 1.0
+ else:
+ w1 = 1.0
+ w2 = 1.0
+ normalz = 0.0
+ slice = []
+ step = (2.0*pi)/float(nparts)
+ angle = 0.0
+ for i in range(nparts+1):
+ vx = cos(angle)
+ vy = sin(angle)
+ slice.append( ((vx*w1,vy*w1,z1), (vx*w1, vy*w1, z1*normalz)) )
+ slice.append( ((vx*w2,vy*w2,z2), (vx*w2, vy*w2, z2*normalz)) )
+ angle = angle + step
+ return slice
#
# Drawcylinder : draw the cylinder
#
curobj = struct()
curobj.curobj = 1
def drawcylinder(cyl):
- obj = curobj.curobj
- curobj.curobj = curobj.curobj+1
- makeobj(obj)
- for slice in cyl:
- bgntmesh()
- vnarray(slice)
- endtmesh()
- closeobj()
- return obj
+ obj = curobj.curobj
+ curobj.curobj = curobj.curobj+1
+ makeobj(obj)
+ for slice in cyl:
+ bgntmesh()
+ vnarray(slice)
+ endtmesh()
+ closeobj()
+ return obj
#
def drawnormals(cyl):
- for slice in cyl:
- for triang in slice:
- bgnline()
- v3f(triang[0])
- v3f(triang[0][0] + triang[1][0], triang[0][1] + triang[1][1], triang[0][2] + triang[1][2])
- endline()
+ for slice in cyl:
+ for triang in slice:
+ bgnline()
+ v3f(triang[0])
+ v3f(triang[0][0] + triang[1][0], triang[0][1] + triang[1][1], triang[0][2] + triang[1][2])
+ endline()
def drawfloors():
- obj = curobj.curobj
- curobj.curobj = curobj.curobj+1
- makeobj(obj)
- bgnpolygon()
- v3i(4,6,-6)
- v3i(-6,6,-6)
- v3i(-6,-6,-6)
- v3i(4,-6,-6)
- endpolygon()
- for floor in range(3):
- pos = -1 + 5*floor
- bgnpolygon()
- v3i(4,4,pos)
- v3i(-6,4,pos)
- v3i(-6,6,pos)
- v3i(4,6,pos)
- endpolygon()
- bgnpolygon()
- v3i(-4,4,pos)
- v3i(-4,-4,pos)
- v3i(-6,-4,pos)
- v3i(-6,4,pos)
- endpolygon()
- bgnpolygon()
- v3i(-6,-4,pos)
- v3i(-6,-6,pos)
- v3i(4,-6,pos)
- v3i(4,-4,pos)
- endpolygon()
- closeobj()
- return obj
+ obj = curobj.curobj
+ curobj.curobj = curobj.curobj+1
+ makeobj(obj)
+ bgnpolygon()
+ v3i(4,6,-6)
+ v3i(-6,6,-6)
+ v3i(-6,-6,-6)
+ v3i(4,-6,-6)
+ endpolygon()
+ for floor in range(3):
+ pos = -1 + 5*floor
+ bgnpolygon()
+ v3i(4,4,pos)
+ v3i(-6,4,pos)
+ v3i(-6,6,pos)
+ v3i(4,6,pos)
+ endpolygon()
+ bgnpolygon()
+ v3i(-4,4,pos)
+ v3i(-4,-4,pos)
+ v3i(-6,-4,pos)
+ v3i(-6,4,pos)
+ endpolygon()
+ bgnpolygon()
+ v3i(-6,-4,pos)
+ v3i(-6,-6,pos)
+ v3i(4,-6,pos)
+ v3i(4,-4,pos)
+ endpolygon()
+ closeobj()
+ return obj
def drawdoors():
- obj = curobj.curobj
- curobj.curobj = curobj.curobj+1
- makeobj(obj)
- for floor in range(3):
- pos = -1+5*floor
- bgnpolygon()
- v3i(-2,6,pos)
- v3i(-2,6,pos+3)
- v3i(0,6,pos+3)
- v3i(0,6,pos)
- endpolygon()
- closeobj()
- return obj
+ obj = curobj.curobj
+ curobj.curobj = curobj.curobj+1
+ makeobj(obj)
+ for floor in range(3):
+ pos = -1+5*floor
+ bgnpolygon()
+ v3i(-2,6,pos)
+ v3i(-2,6,pos+3)
+ v3i(0,6,pos+3)
+ v3i(0,6,pos)
+ endpolygon()
+ closeobj()
+ return obj
def drawrailing():
- obj = curobj.curobj
- curobj.curobj = curobj.curobj+1
- makeobj(obj)
- for floor in range(3):
- pos = -1 + 5*floor
- bgnpolygon()
- v3i(4,4,pos)
- v3i(4,4,pos-1)
- v3i(-4,4,pos-1)
- v3i(-4,4,pos)
- endpolygon()
- bgnpolygon()
- v3i(-4,4,pos)
- v3i(-4,4,pos-1)
- v3i(-4,-4,pos-1)
- v3i(-4,-4,pos)
- endpolygon()
- bgnpolygon()
- v3i(-4,-4,pos)
- v3i(-4,-4,pos-1)
- v3i(4,-4,pos-1)
- v3i(4,-4,pos)
- endpolygon()
- closeobj()
- return obj
+ obj = curobj.curobj
+ curobj.curobj = curobj.curobj+1
+ makeobj(obj)
+ for floor in range(3):
+ pos = -1 + 5*floor
+ bgnpolygon()
+ v3i(4,4,pos)
+ v3i(4,4,pos-1)
+ v3i(-4,4,pos-1)
+ v3i(-4,4,pos)
+ endpolygon()
+ bgnpolygon()
+ v3i(-4,4,pos)
+ v3i(-4,4,pos-1)
+ v3i(-4,-4,pos-1)
+ v3i(-4,-4,pos)
+ endpolygon()
+ bgnpolygon()
+ v3i(-4,-4,pos)
+ v3i(-4,-4,pos-1)
+ v3i(4,-4,pos-1)
+ v3i(4,-4,pos)
+ endpolygon()
+ closeobj()
+ return obj
def drawwalls():
- obj = curobj.curobj
- curobj.curobj = curobj.curobj+1
- makeobj(obj)
- bgnpolygon()
- v3i(4,6,-6)
- v3i(4,6,18)
- v3i(-6,6,18)
- v3i(-6,6,-6)
- endpolygon()
- bgnpolygon()
- v3i(-6,6,-6)
- v3i(-6,6,18)
- v3i(-6,-6,18)
- v3i(-6,-6,-6)
- endpolygon()
- bgnpolygon()
- v3i(-6,-6,-6)
- v3i(-6,-6,18)
- v3i(4,-6,18)
- v3i(4,-6,-6)
- endpolygon()
- bgnpolygon()
- v3i(4,-6,-6)
- v3i(4,-6,18)
- v3i(4,4,18)
- v3i(4,4,-6)
- endpolygon()
- closeobj()
- return obj
+ obj = curobj.curobj
+ curobj.curobj = curobj.curobj+1
+ makeobj(obj)
+ bgnpolygon()
+ v3i(4,6,-6)
+ v3i(4,6,18)
+ v3i(-6,6,18)
+ v3i(-6,6,-6)
+ endpolygon()
+ bgnpolygon()
+ v3i(-6,6,-6)
+ v3i(-6,6,18)
+ v3i(-6,-6,18)
+ v3i(-6,-6,-6)
+ endpolygon()
+ bgnpolygon()
+ v3i(-6,-6,-6)
+ v3i(-6,-6,18)
+ v3i(4,-6,18)
+ v3i(4,-6,-6)
+ endpolygon()
+ bgnpolygon()
+ v3i(4,-6,-6)
+ v3i(4,-6,18)
+ v3i(4,4,18)
+ v3i(4,4,-6)
+ endpolygon()
+ closeobj()
+ return obj
def axis():
- bgnline()
- cpack(0xff0000)
- v3i(-1,0,0)
- v3i(1,0,0)
- v3f(1.0, 0.1, 0.1)
- endline()
- bgnline()
- cpack(0xff00)
- v3i(0,-1,0)
- v3i(0,1,0)
- v3f(0.1, 1.0, 0.1)
- endline()
- bgnline()
- cpack(0xff)
- v3i(0,0,-1)
- v3i(0,0,1)
- v3f(0.1,0.1,1.0)
- endline()
+ bgnline()
+ cpack(0xff0000)
+ v3i(-1,0,0)
+ v3i(1,0,0)
+ v3f(1.0, 0.1, 0.1)
+ endline()
+ bgnline()
+ cpack(0xff00)
+ v3i(0,-1,0)
+ v3i(0,1,0)
+ v3f(0.1, 1.0, 0.1)
+ endline()
+ bgnline()
+ cpack(0xff)
+ v3i(0,0,-1)
+ v3i(0,0,1)
+ v3f(0.1,0.1,1.0)
+ endline()
#
green_velvet = [ DIFFUSE, 0.05, 0.4, 0.05, LMNULL]
silver = [ DIFFUSE, 0.3, 0.3, 0.3, SPECULAR, 0.9, 0.9, 0.95, \
- SHININESS, 40.0, LMNULL]
+ SHININESS, 40.0, LMNULL]
floormat = [ AMBIENT, 0.5, 0.25, 0.15, DIFFUSE, 0.5, 0.25, 0.15, SPECULAR, 0.6, 0.3, 0.2, SHININESS, 20.0, LMNULL]
wallmat = [ DIFFUSE, 0.4, 0.2, 0.1, AMBIENT, 0.4, 0.20, 0.10, SPECULAR, 0.0, 0.0, 0.0, SHININESS, 20.0, LMNULL]
offwhite = [ DIFFUSE, 0.8, 0.8, 0.6, AMBIENT, 0.8, 0.8, 0.6, SPECULAR, 0.9, 0.9, 0.9, SHININESS, 30.0, LMNULL]
doormat = [ DIFFUSE, 0.1, 0.2, 0.5, AMBIENT, 0.2, 0.4, 1.0, SPECULAR, 0.2, 0.4, 1.0, SHININESS, 60.0, LMNULL]
toplight = [ LCOLOR, 1.0, 1.0, 0.5, \
- POSITION, 0.0, 0.0, 11.0, 1.0, LMNULL]
+ POSITION, 0.0, 0.0, 11.0, 1.0, LMNULL]
floor1light = [ LCOLOR, 1.0, 1.0, 1.0, POSITION, 3.9, -3.9, 0.0, 1.0, \
- SPOTDIRECTION, 1.0, 1.0, 0.0, SPOTLIGHT, 10.0, 90.0, LMNULL]
+ SPOTDIRECTION, 1.0, 1.0, 0.0, SPOTLIGHT, 10.0, 90.0, LMNULL]
lmodel = [ AMBIENT, 0.92, 0.8, 0.5, LOCALVIEWER, 1.0, LMNULL]
#
def lighting():
- lmdef(DEFMATERIAL, 1, green_velvet)
- lmdef(DEFMATERIAL, 2, silver)
- lmdef(DEFMATERIAL, 3, floormat)
- lmdef(DEFMATERIAL, 4, wallmat)
- lmdef(DEFMATERIAL, 5, offwhite)
- lmdef(DEFMATERIAL, 6, doormat)
- lmdef(DEFLIGHT, 1, toplight)
- lmdef(DEFLIGHT, 2, floor1light)
- lmdef(DEFLMODEL, 1, lmodel)
- lmbind(MATERIAL, 1)
- lmbind(LIGHT0, 1)
- lmbind(LIGHT1, 2)
- lmbind(LMODEL, 1)
+ lmdef(DEFMATERIAL, 1, green_velvet)
+ lmdef(DEFMATERIAL, 2, silver)
+ lmdef(DEFMATERIAL, 3, floormat)
+ lmdef(DEFMATERIAL, 4, wallmat)
+ lmdef(DEFMATERIAL, 5, offwhite)
+ lmdef(DEFMATERIAL, 6, doormat)
+ lmdef(DEFLIGHT, 1, toplight)
+ lmdef(DEFLIGHT, 2, floor1light)
+ lmdef(DEFLMODEL, 1, lmodel)
+ lmbind(MATERIAL, 1)
+ lmbind(LIGHT0, 1)
+ lmbind(LIGHT1, 2)
+ lmbind(LMODEL, 1)
IdMat=[1.0,0.0,0.0,0.0, 0.0,1.0,0.0,0.0, 0.0,0.0,1.0,0.0, 0.0,0.0,0.0,1.0]
#
def defun(axis):
- done = 0
- while not done:
- print 'F'+axis+'(t) = ',
- s = sys.stdin.readline(100)
- print
- try:
- s = 'def f'+axis+'(t): return '+s
- exec(s, main_dict)
- done = 1
- except RuntimeError:
- print 'Sorry, there is a syntax error in your expression'
+ done = 0
+ while not done:
+ print 'F'+axis+'(t) = ',
+ s = sys.stdin.readline(100)
+ print
+ try:
+ s = 'def f'+axis+'(t): return '+s
+ exec(s, main_dict)
+ done = 1
+ except RuntimeError:
+ print 'Sorry, there is a syntax error in your expression'
def getfunctions():
- print 'Welcome to the CWI art simulator. You can now enter X, Y and Z'
- print 'coordinates as a function of t.'
- print 'Normal trig functions are available. Please use floating point'
- print 'values only (so 0.0 for 0). Comments to jack@cwi.nl'
- defun('x')
- defun('y')
- defun('z')
- print 'Ok, here you go. Use mouse+right button to move up/down,'
- print 'mouse+middle to speed up/slow down time. type ESC to quit simulation'
+ print 'Welcome to the CWI art simulator. You can now enter X, Y and Z'
+ print 'coordinates as a function of t.'
+ print 'Normal trig functions are available. Please use floating point'
+ print 'values only (so 0.0 for 0). Comments to jack@cwi.nl'
+ defun('x')
+ defun('y')
+ defun('z')
+ print 'Ok, here you go. Use mouse+right button to move up/down,'
+ print 'mouse+middle to speed up/slow down time. type ESC to quit simulation'
def main():
- getfunctions()
- foreground()
- prefposition(100,600,100,600)
- void = winopen('cyl')
- qdevice(ESCKEY)
- qdevice(MOUSE1)
- qdevice(MOUSE2)
- qdevice(PKEY)
- RGBmode()
- doublebuffer()
- gconfig()
- zbuffer(1)
- mmode(MVIEWING)
- perspective(400, 1.0, 1.0, 20.0)
- loadmatrix(IdMat)
- vx = 0.0
- vy = -6.0
- vz = 0.0
- lookat(0.0, -6.0, 0.0, 0.0, 0.0, 0.0, 0)
- lighting()
- t = -1.0
- step = 1.0
- bol = mkcyl(12,24, 1)
- cable = mkcyl(1, 6, 0)
- floors = drawfloors()
- walls = drawwalls()
- pillar = mkcyl(1,4,0)
- railing = drawrailing()
- doors = drawdoors()
- shademodel(GOURAUD)
- mousing = -1
- pausing = 0
- while 1:
- #
- # Check for some user input
- #
- if qtest():
- dev, value = qread()
- if dev == PKEY and value == 1:
- pausing = 1
- if dev == ESCKEY:
- break
- elif (dev==MOUSE1 or dev==MOUSE2) and value == 1:
- if mousing > 0:
- vx = 0.0
- vy = -6.0
- vz = 0.0
- mousing = dev
- oldx = getvaluator(MOUSEX)
- oldy = getvaluator(MOUSEY)
- elif (dev==MOUSE1 or dev==MOUSE2):
- mousing = -1
- if mousing >= 0:
- newx = getvaluator(MOUSEX)
- newy = getvaluator(MOUSEY)
- if newy <> oldy and mousing==MOUSE1:
- vz = vz + float(newy - oldy)/100.0
- dist = sqrt(vx*vx + vy*vy + vz*vz)
- perspective(400, 1.0, 1.0, dist+16.0)
- loadmatrix(IdMat)
- if vz < 0.0:
- lookat(vx, vy, vz, 0.0, 0.0, 0.0, 1800)
- else:
- lookat(vx, vy, vz, 0.0, 0.0, 0.0, 0)
- if newy <> oldy and mousing==MOUSE2:
- step = step * exp(float(newy-oldy)/400.0)
- if getbutton(CTRLKEY) == 0:
- t = t + step
- else:
- t = t - step
- if getbutton(LEFTSHIFTKEY) == 0:
- shademodel(GOURAUD)
- else:
- shademodel(FLAT)
- #
- # Draw background and axis
- cpack(0x105090)
- clear()
- zclear()
- cpack(0x905010)
- axis()
- #
- # Draw object
- #
- bolx = fx(t)
- boly = fy(t)
- bolz = fz(t)
- err = ''
- if bolx < -4.0 or bolx > 4.0:
- err = 'X('+`bolx`+') out of range [-4,4]'
- if boly < -4.0 or boly > 4.0:
- err = 'Y('+`boly`+') out of range [-4,4]'
- if bolz < -4.0 or bolz > 8.0:
- err = 'Z('+`bolz`+') out of range [-4,8]'
- if not err:
- pushmatrix()
- translate(bolx, boly, bolz)
- scale(0.3, 0.3, 0.3)
- lmbind(MATERIAL, 2)
- callobj(bol)
- popmatrix()
- #
- # Draw the cables
- #
- bolz = bolz + 0.3
- pushmatrix()
- linesmooth(SML_ON)
- bgnline()
- v3i(-4,-4,9)
- v3f(bolx, boly, bolz)
- endline()
- bgnline()
- v3i(-4,4,9)
- v3f(bolx, boly, bolz)
- endline()
- bgnline()
- v3i(4,-4,9)
- v3f(bolx, boly, bolz)
- endline()
- bgnline()
- v3i(4,4,9)
- v3f(bolx, boly, bolz)
- endline()
- popmatrix()
- #
- # draw the floors
- #
- lmbind(MATERIAL, 3)
- callobj(floors)
- lmbind(MATERIAL, 4)
- callobj(walls)
- lmbind(MATERIAL, 5)
- pushmatrix()
- translate(-4.5,4.5,3.0)
- scale(0.2,0.2,9.0)
- rotate(450,'z')
- callobj(pillar)
- popmatrix()
- callobj(railing)
- lmbind(MATERIAL, 6)
- pushmatrix()
- translate(0.0, -0.01, 0.0)
- callobj(doors)
- popmatrix()
- if mousing == MOUSE2 or err:
- cpack(0xff0000)
- cmov(0.0, 0.0, 0.4)
- charstr('t='+`t`)
- if mousing == MOUSE2:
- cpack(0xff0000)
- cmov(0.0, 0.0, 0.2)
- charstr('delta-t='+`step`)
- if err:
- cpack(0xff00)
- cmov(0.0, 0.0, 0.2)
- print err
- charstr(err)
- pausing = 1
- if pausing:
- cpack(0xff00)
- cmov(0.0, 0.0, 0.0)
- charstr('Pausing, type P to continue')
- swapbuffers()
- if pausing:
- while 1:
- dv=qread()
- if dv==(PKEY,1):
- break
- if dv==(ESCKEY,1):
- sys.exit(0)
- pausing = 0
+ getfunctions()
+ foreground()
+ prefposition(100,600,100,600)
+ void = winopen('cyl')
+ qdevice(ESCKEY)
+ qdevice(MOUSE1)
+ qdevice(MOUSE2)
+ qdevice(PKEY)
+ RGBmode()
+ doublebuffer()
+ gconfig()
+ zbuffer(1)
+ mmode(MVIEWING)
+ perspective(400, 1.0, 1.0, 20.0)
+ loadmatrix(IdMat)
+ vx = 0.0
+ vy = -6.0
+ vz = 0.0
+ lookat(0.0, -6.0, 0.0, 0.0, 0.0, 0.0, 0)
+ lighting()
+ t = -1.0
+ step = 1.0
+ bol = mkcyl(12,24, 1)
+ cable = mkcyl(1, 6, 0)
+ floors = drawfloors()
+ walls = drawwalls()
+ pillar = mkcyl(1,4,0)
+ railing = drawrailing()
+ doors = drawdoors()
+ shademodel(GOURAUD)
+ mousing = -1
+ pausing = 0
+ while 1:
+ #
+ # Check for some user input
+ #
+ if qtest():
+ dev, value = qread()
+ if dev == PKEY and value == 1:
+ pausing = 1
+ if dev == ESCKEY:
+ break
+ elif (dev==MOUSE1 or dev==MOUSE2) and value == 1:
+ if mousing > 0:
+ vx = 0.0
+ vy = -6.0
+ vz = 0.0
+ mousing = dev
+ oldx = getvaluator(MOUSEX)
+ oldy = getvaluator(MOUSEY)
+ elif (dev==MOUSE1 or dev==MOUSE2):
+ mousing = -1
+ if mousing >= 0:
+ newx = getvaluator(MOUSEX)
+ newy = getvaluator(MOUSEY)
+ if newy <> oldy and mousing==MOUSE1:
+ vz = vz + float(newy - oldy)/100.0
+ dist = sqrt(vx*vx + vy*vy + vz*vz)
+ perspective(400, 1.0, 1.0, dist+16.0)
+ loadmatrix(IdMat)
+ if vz < 0.0:
+ lookat(vx, vy, vz, 0.0, 0.0, 0.0, 1800)
+ else:
+ lookat(vx, vy, vz, 0.0, 0.0, 0.0, 0)
+ if newy <> oldy and mousing==MOUSE2:
+ step = step * exp(float(newy-oldy)/400.0)
+ if getbutton(CTRLKEY) == 0:
+ t = t + step
+ else:
+ t = t - step
+ if getbutton(LEFTSHIFTKEY) == 0:
+ shademodel(GOURAUD)
+ else:
+ shademodel(FLAT)
+ #
+ # Draw background and axis
+ cpack(0x105090)
+ clear()
+ zclear()
+ cpack(0x905010)
+ axis()
+ #
+ # Draw object
+ #
+ bolx = fx(t)
+ boly = fy(t)
+ bolz = fz(t)
+ err = ''
+ if bolx < -4.0 or bolx > 4.0:
+ err = 'X('+`bolx`+') out of range [-4,4]'
+ if boly < -4.0 or boly > 4.0:
+ err = 'Y('+`boly`+') out of range [-4,4]'
+ if bolz < -4.0 or bolz > 8.0:
+ err = 'Z('+`bolz`+') out of range [-4,8]'
+ if not err:
+ pushmatrix()
+ translate(bolx, boly, bolz)
+ scale(0.3, 0.3, 0.3)
+ lmbind(MATERIAL, 2)
+ callobj(bol)
+ popmatrix()
+ #
+ # Draw the cables
+ #
+ bolz = bolz + 0.3
+ pushmatrix()
+ linesmooth(SML_ON)
+ bgnline()
+ v3i(-4,-4,9)
+ v3f(bolx, boly, bolz)
+ endline()
+ bgnline()
+ v3i(-4,4,9)
+ v3f(bolx, boly, bolz)
+ endline()
+ bgnline()
+ v3i(4,-4,9)
+ v3f(bolx, boly, bolz)
+ endline()
+ bgnline()
+ v3i(4,4,9)
+ v3f(bolx, boly, bolz)
+ endline()
+ popmatrix()
+ #
+ # draw the floors
+ #
+ lmbind(MATERIAL, 3)
+ callobj(floors)
+ lmbind(MATERIAL, 4)
+ callobj(walls)
+ lmbind(MATERIAL, 5)
+ pushmatrix()
+ translate(-4.5,4.5,3.0)
+ scale(0.2,0.2,9.0)
+ rotate(450,'z')
+ callobj(pillar)
+ popmatrix()
+ callobj(railing)
+ lmbind(MATERIAL, 6)
+ pushmatrix()
+ translate(0.0, -0.01, 0.0)
+ callobj(doors)
+ popmatrix()
+ if mousing == MOUSE2 or err:
+ cpack(0xff0000)
+ cmov(0.0, 0.0, 0.4)
+ charstr('t='+`t`)
+ if mousing == MOUSE2:
+ cpack(0xff0000)
+ cmov(0.0, 0.0, 0.2)
+ charstr('delta-t='+`step`)
+ if err:
+ cpack(0xff00)
+ cmov(0.0, 0.0, 0.2)
+ print err
+ charstr(err)
+ pausing = 1
+ if pausing:
+ cpack(0xff00)
+ cmov(0.0, 0.0, 0.0)
+ charstr('Pausing, type P to continue')
+ swapbuffers()
+ if pausing:
+ while 1:
+ dv=qread()
+ if dv==(PKEY,1):
+ break
+ if dv==(ESCKEY,1):
+ sys.exit(0)
+ pausing = 0
#
try:
main()
self.rwOK.release()
def write_to_read(self):
- self.rwOK.acquire()
- if not self.writing:
- raise ValueError, \
- '.write_to_read() invoked without an active writer'
- self.writing = 0
- self.nw = self.nw - 1
- self.nr = self.nr + 1
- if not self.nw:
- self.readOK.broadcast()
- self.rwOK.release()
+ self.rwOK.acquire()
+ if not self.writing:
+ raise ValueError, \
+ '.write_to_read() invoked without an active writer'
+ self.writing = 0
+ self.nw = self.nw - 1
+ self.nr = self.nr + 1
+ if not self.nw:
+ self.readOK.broadcast()
+ self.rwOK.release()
# The rest of the file is a test case, that runs a number of parallelized
# quicksorts in parallel. If it works, you'll get about 600 lines of
if compressing:
output.write('\037\213\010') # Write the header, ...
- output.write(chr(FNAME)) # ... flag byte ...
+ output.write(chr(FNAME)) # ... flag byte ...
- import os # ... modification time ...
+ import os # ... modification time ...
statval=os.stat(filename)
mtime=statval[8]
write32(output, mtime)
- output.write('\002') # ... slowest compression alg. ...
- output.write('\377') # ... OS (=unknown) ...
- output.write(filename+'\000') # ... original filename ...
+ output.write('\002') # ... slowest compression alg. ...
+ output.write('\377') # ... OS (=unknown) ...
+ output.write(filename+'\000') # ... original filename ...
crcval=zlib.crc32("")
compobj=zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS,
- zlib.DEF_MEM_LEVEL, 0)
+ zlib.DEF_MEM_LEVEL, 0)
while (1):
- data=input.read(1024)
- if data=="": break
- crcval=zlib.crc32(data, crcval)
- output.write(compobj.compress(data))
+ data=input.read(1024)
+ if data=="": break
+ crcval=zlib.crc32(data, crcval)
+ output.write(compobj.compress(data))
output.write(compobj.flush())
- write32(output, crcval) # ... the CRC ...
- write32(output, statval[6]) # and the file size.
+ write32(output, crcval) # ... the CRC ...
+ write32(output, statval[6]) # and the file size.
else:
magic=input.read(2)
if magic!='\037\213':
- print 'Not a gzipped file' ; sys.exit(0)
+ print 'Not a gzipped file' ; sys.exit(0)
if ord(input.read(1))!=8:
- print 'Unknown compression method' ; sys.exit(0)
+ print 'Unknown compression method' ; sys.exit(0)
flag=ord(input.read(1))
- input.read(4+1+1) # Discard modification time,
- # extra flags, and OS byte.
+ input.read(4+1+1) # Discard modification time,
+ # extra flags, and OS byte.
if flag & FEXTRA:
- # Read & discard the extra field, if present
- xlen=ord(input.read(1))
- xlen=xlen+256*ord(input.read(1))
- input.read(xlen)
+ # Read & discard the extra field, if present
+ xlen=ord(input.read(1))
+ xlen=xlen+256*ord(input.read(1))
+ input.read(xlen)
if flag & FNAME:
- # Read and discard a null-terminated string containing the filename
- while (1):
- s=input.read(1)
- if s=='\000': break
+ # Read and discard a null-terminated string containing the filename
+ while (1):
+ s=input.read(1)
+ if s=='\000': break
if flag & FCOMMENT:
- # Read and discard a null-terminated string containing a comment
- while (1):
- s=input.read(1)
- if s=='\000': break
+ # Read and discard a null-terminated string containing a comment
+ while (1):
+ s=input.read(1)
+ if s=='\000': break
if flag & FHCRC:
- input.read(2) # Read & discard the 16-bit header CRC
+ input.read(2) # Read & discard the 16-bit header CRC
decompobj=zlib.decompressobj(-zlib.MAX_WBITS)
crcval=zlib.crc32("")
length=0
while (1):
- data=input.read(1024)
- if data=="": break
- decompdata=decompobj.decompress(data)
- print len(decompdata)
- output.write(decompdata) ; length=length+len(decompdata)
- crcval=zlib.crc32(decompdata, crcval)
+ data=input.read(1024)
+ if data=="": break
+ decompdata=decompobj.decompress(data)
+ print len(decompdata)
+ output.write(decompdata) ; length=length+len(decompdata)
+ crcval=zlib.crc32(decompdata, crcval)
decompdata=decompobj.flush()
output.write(decompdata) ; length=length+len(decompdata)
crcval=zlib.crc32(decompdata, crcval)
projects / python / commitdiff