Limnoria/src/world.py

#!/usr/bin/env python

###
# Copyright (c) 2002, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#   * Redistributions of source code must retain the above copyright notice,
#     this list of conditions, and the following disclaimer.
#   * Redistributions in binary form must reproduce the above copyright notice,
#     this list of conditions, and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#   * Neither the name of the author of this software nor the name of
#     contributors to this software may be used to endorse or promote products
#     derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

"""
Module for general worldly stuff, like global variables and whatnot.
"""

import fix

import gc
import os
import sre
import time
import types
import atexit
try:
    import msvcrt
except ImportError:
    pass

import conf
import debug

startedAt = 0.0

threadsSpawned = 1 # Starts at one for the initial "thread."
commandsProcessed = 0
###
# End Global Values.
###

try:
    ignore(ircs)
except NameError:
    ircs = []

try:
    ignore(flushers)
except NameError:
    flushers = [] # A periodic function will flush all these.

def flush():
    """Flushes all the registered flushers."""
    for f in flushers:
        f()

try:
    ignore(tempvars)
except NameError:
    tempvars = {} # A storage place for temporary variables that need to be
                  # globally accessible.


def upkeep(): # Function to be run on occasion to do upkeep stuff.
    """Does upkeep (like flushing, garbage collection, etc.)"""
    collected = gc.collect()
    if os.name == 'nt':
        try:
            msvcrt.heapmin()
        except IOError: # Win98 sux0rs!
            pass
    if gc.garbage:
        debug.msg('Uncollectable garbage: %s' % gc.garbage, 'normal')
    if 'noflush' not in tempvars:
        flush()
    debug.msg('Regexp cache size: %s' % len(sre._cache), 'verbose')
    msg = '%s upkeep ran.' % time.strftime(conf.logTimestampFormat)
    debug.msg(msg, 'verbose')
    return collected

atexit.register(upkeep)

'''
def superReload(oldmodule):
    ###
    # So here is how this baby works:
    #   Reload the module.
    #   Iterate through the old module, finding classes and functions that are
    #     also in the new module.
    #   Add an __getattribute__ or __getattr__ method to those classes that are
    #     present in the new module.  This method will, when called, change
    #     the __class__ of the instance to point to the new class.
    #   Change the func_code, func_defaults, and func_doc of any functions or
    #     methods or generators we run across, just in case someone is holding
    #     a reference to them instead of calling them by name.
    ###
    """Reload a module and make objects auto-update."""
    # reload(module) modifies module in-place, so we need a copy of its
    # __dict__ to iterate through.
    olddict = copy.copy(oldmodule.__dict__)
    newmodule = reload(oldmodule)
    newdict = newmodule.__dict__
    for (name, oldvalue) in olddict.iteritems():
        if name in newdict:
            newvalue = newdict[name]
            oldtype = type(oldvalue)
            # We have to pass in newvalue because of Python scoping.
            def updater(self, s, newvalue=newvalue):
                # This function is to be an __getattr__ or __getattribute__.
                try:
                    self.__class__ = newvalue
                except:
                    debug.recoverableException()
                    try:
                        del self.__class__.__getattribute__
                    except AttributeError:
                        del self.__class__.__getattr__
                return getattr(self, s)
            if oldtype == types.TypeType and \
               oldvalue.__module__ == newmodule.__name__:
                # New-style classes support __getattribute__, which is
                # called on *any* attribute access, so they get updated
                # the first time they are used after a reload.
                if not (issubclass(oldvalue, str) or \
                        issubclass(oldvalue, long) or \
                        issubclass(oldvalue, tuple)):
                    oldvalue.__getattribute__ = updater
            elif oldtype == types.ClassType and\
                 oldvalue.__module__ == newmodule.__name__:
                # Old-style classes can only use getattr, so they might not
                # update right away.  Hopefully they will, but to solve
                # this problem I just use new-style classes.
                oldvalue.__getattr__ = updater
            elif oldtype == type(newvalue):
                if oldtype == types.FunctionType or\
                   oldtype == types.GeneratorType:
                    oldvalue.func_code = newvalue.func_code
                    oldvalue.func_defaults = newvalue.func_defaults
                    oldvalue.func_doc = newvalue.func_doc
                elif oldtype == types.MethodType:
                    oldfunc = oldvalue.im_func
                    newfunc = newvalue.im_func
                    oldfunc.func_code = newfunc.func_code
                    oldfunc.func_defaults = newfunc.func_defaults
                    oldfunc.func_doc = newfunc.func_doc
    # Update the linecache, so tracebacks show the proper lines.
    linecache.checkcache()
    return newmodule
'''

try:
    # This makes the module reload properly; we don't want to lose oldobjects
    # on reload.
    oldobjects
except NameError:
    oldobjects = {}
def superReload(module):
    """Reloads a module hardcore.  But kinda broken -- don't use it."""
    def updateFunction(old, new, attrs):
        """Update all attrs in old to the same attrs in new."""
        for name in attrs:
            setattr(old, name, getattr(new, name))
    for (name, object) in module.__dict__.iteritems():
        # For every attribute of the old module, keep the object.
        key = (module.__name__, name)
        oldobjects.setdefault(key, []).append(object)
    module = reload(module)
    for name, newobj in module.__dict__.iteritems():
        # For every attribute in the new module...
        key = (module.__name__, name)
        if key in oldobjects: # If the same attribute was in the old module...
            for oldobj in oldobjects[key]:
                # Give it the new attributes :)
                if type(newobj) == types.ClassType:
                    toRemove = []
                    for k in oldobj.__dict__:
                        if k not in newobj.__dict__:
                            toRemove.append(k)
                    for k in toRemove:
                        del oldobj.__dict__[k]
                    oldobj.__dict__.update(newobj.__dict__)
#                elif type(newobj) == types.TypeType:
#                    if hasattr(oldobj, '__dict__'):
#                        oldobj.__dict__.update(newobj.__dict__)
                elif type(newobj) == types.FunctionType:
                    updateFunction(oldobj, newobj, ('func_code',
                                                    'func_defaults',
                                                    'func_doc'))
                elif type(newobj) == types.MethodType:
                    updateFunction(oldobj.im_func, newobj.im_func,
                                  ('func_code', 'func_defaults', 'func_doc'))
    return module

#################################################
#################################################
#################################################
## Don't even *think* about messing with this. ##
#################################################
#################################################
#################################################
startup = False
testing = False

# vim:set shiftwidth=4 tabstop=8 expandtab textwidth=78: