#charset "us-ascii"

/*
 *   Copyright (c) 2008 Michael J. Roberts.  All Rights Reserved.
 *   
 *   This module provides the run-time component of "multi-methods" in TADS
 *   3.  This works with the compiler to implement a multiple-dispatch
 *   system.
 *   
 *   Multi-methods are essentially a combination of regular object methods
 *   and "overloaded functions" in languages like C++.  Like a regular
 *   object method, multi-methods are polymorphic: you can define several
 *   incarnations of the same function name, with different parameter
 *   types, the system picks the right binding for each invocation
 *   dynamically, based on the actual argument values at run-time.  Unlike
 *   regular methods, though, the selection is made on ALL of the argument
 *   types, not just a special "self" argument.  In that respect,
 *   multi-methods are like overloaded functions in C++; but multi-methods
 *   differ from C++ overloading in that the selection of which method to
 *   call is made dynamically at run-time, not at compile time.
 *   
 *   There are two main uses for multi-methods.
 *   
 *   First, most obviously, multi-methods provide what's known as "multiple
 *   dispatch" semantics.  There are some situations (actually, quite a
 *   few) where the ordinary Object Oriented notion of polymorphism -
 *   selecting a method based on a single target object - doesn't quite do
 *   the trick, because what you really want to do is select a particular
 *   method based on the *combination* of objects involved in an operation.
 *   Some canonical examples are calculating intersections of shapes in a
 *   graphics program, where you want to select a specialized "Rectangle +
 *   Circle" routine in one case and a "Line + Polygon" routine in another;
 *   or performing file format conversions, where you want to select, say,
 *   a specialized "JPEG to PNG" routine.  In an IF context, the obvious
 *   use is for carrying out multi-object verbs, where you might want a
 *   special routine for PUT (liquid) IN (vessel), and another for PUT
 *   (object) IN (container).
 *   
 *   Second, multi-methods offer a way of extending a class without having
 *   to change the class's source code.  Since a multi-method is defined
 *   externally to any classes it refers to, you can create a method that's
 *   polymorphic on class type - just like a regular method - but as a
 *   syntactically stand-alone function.  This feature isn't as important
 *   in TADS as in some other languages, since TADS lets you do essentially
 *   the same thing with the "modify" syntax; but for some purposes the
 *   multi-method approach might be preferable aesthetically, since it's
 *   wholly external to the class rather than a sort of lexically separate
 *   continuation of the class's code.  (However, as a practical matter,
 *   it's not all that different; our implementation of multi-methods does
 *   in fact modify the original class object, since we store the binding
 *   information in the class objects.)  
 */

#include <tads.h>


/* ------------------------------------------------------------------------ */
/* 
 *   Invoke a multi-method function.  For an expression of the form
 *   
 *.     f(a, b, ...)
 *   
 *   where 'f' has been declared as a multi-method, the compiler will
 *   actually generate code that invokes this function, like so:
 *   
 *.     _multiMethodCall(baseFunc, params);
 *   
 *   'baseFunc' is a function pointer giving the base function; this is a
 *   pointer to the common stub function that the compiler generates to
 *   identify all of the multi-methods with a given name.  'params' is a
 *   list giving the actual parameter values for invoking the function.
 *   
 *   Our job is to find the actual run-time binding for the function given
 *   the actual parameters, and invoke it.  
 */
_multiMethodCall(baseFunc, args)
{
    /* get the function binding lookup information */
    local info = _multiMethodRegistry.boundFuncTab_[baseFunc];

    /* it's an error if there's no binding */
    if (info == nil)
        throw new UnboundMultiMethod(baseFunc, args);

    /* 
     *   Look up the function binding based on the arguments.  To ensure
     *   that we match a function with the correct number of argument, we
     *   have to explicitly add the last-argument placeholder to the list. 
     */
    local func = _multiMethodSelect(info, args + _multiMethodEndOfList);

    /* if we found a binding, invoke it; otherwise throw an error */
    if (func == nil)
        throw new UnboundMultiMethod(baseFunc, args);
    else
        return (func)(args...);
}

/*
 *   Invoke the base multi-method inherited from the given multi-method.
 *   'fromFunc' is a pointer to a multi-method, presumably the one
 *   currently running; we look up the next in line in inheritance order
 *   and invoke it with the given argument list.  
 */
_multiMethodCallInherited(fromFunc, [args])
{
#ifdef MULTMETH_STATIC_INHERITED

    /* static mode - get the cached inheritance information */
    local inh = _multiMethodRegistry.inhTab_[fromFunc];

#else

    /* dynamic mode - get the base function binding */
    local info = _multiMethodRegistry.boundFuncTab_[
        _multiMethodRegistry.baseFuncTab_[fromFunc]];

    /* it's an error if it doesn't exist */
    if (info == nil)
        throw new UnboundInheritedMultiMethod(fromFunc, args);

    /* look up the inherited function based on the actual parameters */
    local inh = _multiMethodInherit(
        fromFunc, info, args + _multiMethodEndOfList);

#endif
    
    /* it's an error if there's no inherited binding */
    if (inh == nil)
        throw new UnboundInheritedMultiMethod(fromFunc, args);

    /* call it */
    return (inh)(args...);
}


/* ------------------------------------------------------------------------ */
/*
 *   Get a pointer to a resolved multi-method function.  This takes a
 *   pointer to the base function for the multi-method and a list of actual
 *   argument values, and returns a function pointer to the specific
 *   version of the multi-method that would be invoked if you called the
 *   multi-method with that argument list.
 *   
 *   For example, if you want to get a pointer to the function that would
 *   be called if you were to call foo(x, y, z), you'd use:
 *   
 *.     local func = getMultiMethodPointer(foo, x, y, z);
 *   
 *   We return a pointer to the individual multi-method function that
 *   matches the argument list, or nil if there's no matching multi-method.
 */
getMultiMethodPointer(baseFunc, [args])
{
    /* get the function binding lookup information */
    local info = _multiMethodRegistry.boundFuncTab_[baseFunc];
    
    /* if there's no binding information, return failure */
    if (info == nil)
        return nil;

    /* look up and return the function binding based on the arguments */
    return _multiMethodSelect(info, args + _multiMethodEndOfList);
}


/* ------------------------------------------------------------------------ */
/*
 *   Resolve a multi-method binding.  This function takes a binding
 *   property ID (the property we assign during the registration process to
 *   generate the binding tables) and a "remaining" argument list.  This
 *   function invokes itself recursively to traverse the arguments from
 *   left to right, so at each recursive invocation, we lop off the
 *   leftmost argument (the one we're working on currently) and pass in the
 *   remaining arguments in the list.
 *   
 *   We look up the binding property on the first argument in the remaining
 *   argument list.  This can yield one of three things:
 *   
 *   - The trivial result is nil, which means that this binding property
 *   has no definition on the first argument.  This doesn't necessarily
 *   mean that the whole function is undefined on the arguments; it only
 *   means that the current inheritance level we're looking at for the
 *   previous argument(s) has no binding.  If we get this result we simply
 *   return nil to tell the caller that it must look at an inherited
 *   binding for the previous argument.
 *   
 *   - If the result is a function pointer, it's the bound function.  This
 *   is the final result for the recursion, so we simply return it.
 *   
 *   - Otherwise, the result will be a new property ID, giving the property
 *   that resolves the binding for the *next* argument.  In this case, we
 *   use this property to resolve the next argument in the list by a
 *   recursive invocation.  If that recursive call succeeds (i.e., returns
 *   a non-nil value), we're done - we simply return the recursive result
 *   as though it were our own.  If it fails, it means that there's no
 *   binding for the particular subclass we're currently working on for the
 *   first argument - however, there could still be a binding for a parent
 *   class of the first argument.  So, we iterate up to any inherited
 *   binding for the first argument, and if we find one, we try again with
 *   the same recursive call.  We continue up our first argument's class
 *   tree until we either find a binding (in which case we return it) or
 *   exhaust the class tree (in which case we return nil).  
 */
_multiMethodSelect(prop, args)
{
    local obj, binding;

    /* 
     *   Get the first argument from the remaining arguments.  If it's not
     *   an object, use the placeholder object for non-object parameter
     *   bindings.  
     */
    local orig = args[1];
    if (dataType(orig) not in (TypeObject, TypeList, TypeSString))
        orig = _multiMethodNonObjectBindings;

    /* get the remaining arguments */
    args = args.sublist(2);

    /* 
     *   Look up the initial binding - this is simply the value of the
     *   binding property for the first argument.  In order to process the
     *   inheritance tree later, we'll need to know where we got this
     *   definition from, so look up the specific defining object.
     *   
     *   If the initial binding property isn't defined, or its value is
     *   explicitly nil, the function isn't bound (or, in the case of nil,
     *   is explicitly unbound).  Inheritance won't help in these cases, so
     *   we can immediately return nil to indicate that we don't have a
     *   binding.  
     */
    if ((obj = orig.propDefined(prop, PropDefGetClass)) == nil
        || (binding = obj.(prop)) == nil)
        return nil;

    /* 
     *   If there are no more arguments, but we didn't just find a final
     *   function binding, we don't have enough arguments to match the
     *   current multi-method path.  Return failure.  
     */
    if (args.length() == 0 && dataType(binding) != TypeFuncPtr)
        return nil;

    /* 
     *   starting at our current defining object for the first argument,
     *   scan up its superclass tree until we find a binding 
     */
    for (;;)
    {
        local ret;

        /* if we have a function pointer, we've found our binding */
        if (dataType(binding) == TypeFuncPtr)
            return binding;

        /* 
         *   Recursively bind the binding for the remaining arguments.  If
         *   we find a binding, we're done - simply return it. 
         */
        if ((ret = _multiMethodSelect(binding, args)) != nil)
            return ret;

        /* 
         *   We didn't find a binding for the remaining arguments, so we
         *   must have chosen too specific a binding for the first
         *   argument.  Look for an inherited value of the binding property
         *   in the next superclass of the object where we found the last
         *   binding value.  
         */
        obj = orig.propInherited(prop, orig, obj, PropDefGetClass);
        if (obj == nil)
            return nil;

        /* we found an inherited value, so retrieve it from the superclass */
        binding = obj.(prop);
    }
}

/*
 *   Select the INHERITED version of a multi-method.  This takes a
 *   particular version of the multi-method, and finds the next version in
 *   inheritance order.
 *   
 *   This is basically a copy of _multiMethodSelect(), with a small amount
 *   of extra logic.  This code repetition isn't good maintenance-wise, and
 *   the two functions could in principle be merged into one.  However,
 *   doing so would have an efficiency cost to _multiMethodSelect(), which
 *   we want to keep as lean as possible.  
 */
_multiMethodInherit(fromFunc, prop, args)
{
    return _multiMethodInheritMain(
        new _MultiMethodInheritCtx(), fromFunc, prop, args);
}

class _MultiMethodInheritCtx: object
    foundFromFunc = nil
;
    
_multiMethodInheritMain(ctx, fromFunc, prop, args)
{
    local obj, binding;

    /* 
     *   Get the first argument from the remaining arguments.  If it's not
     *   an object, use the placeholder object for non-object parameter
     *   bindings.  
     */
    local orig = args[1];
    if (dataType(orig) not in (TypeObject, TypeList, TypeSString))
        orig = _multiMethodNonObjectBindings;

    /* get the remaining arguments */
    args = args.sublist(2);

    /* 
     *   Look up the initial binding - this is simply the value of the
     *   binding property for the first argument.  In order to process the
     *   inheritance tree later, we'll need to know where we got this
     *   definition from, so look up the specific defining object.
     *   
     *   If the initial binding property isn't defined, or its value is
     *   explicitly nil, the function isn't bound (or, in the case of nil,
     *   is explicitly unbound).  Inheritance won't help in these cases, so
     *   we can immediately return nil to indicate that we don't have a
     *   binding.  
     */
    if ((obj = orig.propDefined(prop, PropDefGetClass)) == nil
        || (binding = obj.(prop)) == nil)
        return nil;

    /* 
     *   If there are no more arguments, but we didn't just find a final
     *   function binding, we don't have enough arguments to match the
     *   current multi-method path.  Return failure.  
     */
    if (args.length() == 0 && dataType(binding) != TypeFuncPtr)
        return nil;

    /* 
     *   starting at our current defining object for the first argument,
     *   scan up its superclass tree until we find a binding 
     */
    for (;;)
    {
        /* we haven't found a function binding yet */
        local ret = nil;

        /* 
         *   we either have a function pointer, in which case it's the
         *   actual binding, or a property, in which case it's the next
         *   binding level 
         */
        if (dataType(binding) == TypeFuncPtr)
        {
            /* this is the binding */
            ret = binding;
        }
        else
        {
            /* if there are no more arguments, return failure */
            if (args.length() == 0)
                return nil;

            /* 
             *   Recursively bind the binding for the remaining arguments.
             *   If we find a binding, we're done - simply return it.  
             */
            ret = _multiMethodInheritMain(ctx, fromFunc, binding, args);
        }

        /* check to see if we found a binding */
        if (ret != nil)
        {
            /* 
             *   We found a binding.  If we've already found the inheriting
             *   version, return the first thing we find, since that's the
             *   next inheriting level.  Otherwise, if this is the
             *   inheriting version, note that we've found it, but keep
             *   looking, since we want to find the next one after that.
             *   Otherwise, just keep looking, since we haven't even
             *   reached the overriding version yet. 
             */
            if (ctx.foundFromFunc)
                return ret;
            else if (ret == fromFunc)
                ctx.foundFromFunc = true;
        }
        
        /* 
         *   We didn't find a binding for the remaining arguments, so we
         *   must have chosen too specific a binding for the first
         *   argument.  Look for an inherited value of the binding property
         *   in the next superclass of the object where we found the last
         *   binding value.  
         */
        obj = orig.propInherited(prop, orig, obj, PropDefGetClass);
        if (obj == nil)
            return nil;

        /* we found an inherited value, so retrieve it from the superclass */
        binding = obj.(prop);
    }
}

/* ------------------------------------------------------------------------ */
/*
 *   Unbound multi-method exception.  This is thrown when a call to resolve
 *   a multi-method fails to find a binding, meaning that there's no
 *   definition of the method that matches the types of the arguments.  
 */
class UnboundMultiMethod: Exception
    construct(func, args)
    {
        /* note the function name and argument list */
        func_ = func;
        args_ = args;

        /* look up the function's name */
        name_ = _multiMethodRegistry.funcNameTab_[func];
    }

    /* display an error message describing the exception */
    displayException()
    {
        "Unbound multi-method \"<<name_>>\" (<<args_.length()>> argument(s))";
    }

    /* the base function pointer */
    func_ = nil

    /* the symbol name of the base function */
    name_ = ''

    /* the number of arguments */
    args_ = 0
;

class UnboundInheritedMultiMethod: UnboundMultiMethod
    displayException()
    {
        "No inherited multi-method for \"<<name_>>\" (<<args_.length()>>
        arguments(s))";
    }
;


/* ------------------------------------------------------------------------ */
/*
 *   Base class for our internal placeholder objects for argument list
 *   matching.
 */
class _MultiMethodPlaceholder: object
;

/*
 *   A placeholder object for bindings for non-object arguments.  Whenever
 *   we have an actual argument value that's not an object, we'll look here
 *   for bindings for that parameter.  When registering a function, we'll
 *   register a binding here for any parameter that doesn't have a type
 *   specification.  
 */
_multiMethodNonObjectBindings: _MultiMethodPlaceholder
;

/*
 *   A placeholder object for end-of-list bindings.  When we're matching an
 *   argument list, we'll use this to represent the end of the list so that
 *   we can match the "..." in any varargs functions in the multi-method
 *   set that we're matching against.  
 */
_multiMethodEndOfList: _MultiMethodPlaceholder
;


/* ------------------------------------------------------------------------ */
/*
 *   Register a multi-method.
 *   
 *   The compiler automatically generates a call to this function during
 *   pre-initialization for each defined multi-method.  'baseFunc' is a
 *   pointer to the "base" function - this is a stub function that the
 *   compiler generates to refer to the whole collection of multi-methods
 *   with a given name.  'func' is the pointer to the specific multi-method
 *   we're registering; this is the actual function defined in the code
 *   with a given set of parameter types.  'params' is a list of the
 *   parameter type values; each parameter type in the list is given as a
 *   class object (meaning that the parameter matches that class), nil
 *   (meaning that the parameter matches ANY type of value), or the string
 *   '...' (meaning that this is a "varargs" function, and any number of
 *   additional parameters can be supplied at this point in the parameters;
 *   this is always the last parameter in the list if it's present).  
 */
_multiMethodRegister(baseFunc, func, params)
{
    /* if there's no hash entry for the function yet, add one */
    local tab = _multiMethodRegistry.funcTab_;
    if (tab[baseFunc] == nil)
        tab[baseFunc] = new Vector(10);

    /* add the entry to the list of variants for this function */
    tab[baseFunc].append([func, params]);

    /* add the mapping from the function to the base function */
    _multiMethodRegistry.baseFuncTab_[func] = baseFunc;

    /* also add the function to the direct parameter table */
    _multiMethodRegistry.funcParamTab_[func] = params;
}

/*
 *   Build the method bindings.  The compiler generates a call to this
 *   after all methods have been registered; we run through the list of
 *   registered methods and generate the binding properties in the
 *   referenced objects.  
 */
_multiMethodBuildBindings()
{
    /* no errors yet */
    local errs = [];
    
    /* 
     *   build a lookup table that maps function pointers to symbol names,
     *   so we can look up our function names for diagnostic purposes 
     */
    local nameTab = new LookupTable(128, 256);
    t3GetGlobalSymbols().forEachAssoc(new function(key, val)
    {
        /* if it's a function, store a value-to-name association */
        if (dataType(val) == TypeFuncPtr)
            nameTab[val] = key;
    });

    /* run through each entry in the method table */
    _multiMethodRegistry.funcTab_.forEachAssoc(new function(baseFunc, val)
    {
        /* look up the base function's name */
        local name = nameTab[baseFunc];

        /* add this to the saved name table */
        _multiMethodRegistry.funcNameTab_[baseFunc] = name;

        /* note the number of registered instances of this function */
        local funcCnt = val.length();

        /* 
         *   Assign the initial binding property for this function.  This
         *   is the property that gives us the binding for the first
         *   variant argument.  Each unique multi-method (which is defined
         *   as a multi-method with a given name and a given number of
         *   parameters) has a single initial binding property.  
         */
        local initProp = t3AllocProp();

        /* 
         *   store the binding starter information for the function - to
         *   find the binding on invocation, we'll need the initial binding
         *   property so that we can trace the argument list 
         */
        _multiMethodRegistry.boundFuncTab_[baseFunc] = initProp;

        /* build the argument binding tables */
        for (local i = 1 ; i <= funcCnt ; i++)
        {
            /* get the function binding */
            local func = val[i][1];

            /* get the formal parameter type list for this function */
            local params = val[i][2];
            local paramCnt = params.length();

            /*
             *   If the last formal isn't a varargs placeholder, then we
             *   must explicitly find the end of the list in the actual
             *   parameters in order to match a call.  To match the end of
             *   the list, add the special End-Of-List placeholder to the
             *   formals list.
             *   
             *   This isn't necessary when there's a varargs placeholder
             *   because the placeholder can match zero or more - so it
             *   doesn't matter where the list ends as long as we get to
             *   the varargs slot.  
             */
            if (paramCnt == 0 || params[paramCnt] != '...')
            {
                params += _multiMethodEndOfList;
                ++paramCnt;
            }

            /* start at the initial binding property */
            local prop = initProp;

            /* run through the parameters and build the bindings */
            for (local j = 1 ; j <= paramCnt ; j++)
            {
                /* get this parameter type */
                local origTyp = params[j], typ = origTyp;

                /* 
                 *   If the type is nil, it means that this parameter slot
                 *   can accept any type.  So, map the slot to the generic
                 *   Object type - this will catch everything, since we
                 *   handle non-objects by mapping them to the
                 *   _multiMethodNonObjectBindings placeholder object,
                 *   which like all objects inherits from Object.  This
                 *   means we'll match argument values that are objects or
                 *   non-objects, thus fulfilling our requirement to match
                 *   all values.
                 *   
                 *   If the type is the string '...', it means that this is
                 *   a varargs placeholder argument.  In this case, we need
                 *   to set up a match for the generic Object, in case we
                 *   have one or more actual arguments for the varargs
                 *   portion.  This will also automatically match the case
                 *   where we have no extra arguments, because in this case
                 *   the matcher will try to match the End-Of-List
                 *   placeholder object _multiMethodEndOfList, which (as
                 *   above) inherits from Object and thus picks up the
                 *   any-type binding.
                 *   
                 *   The one tricky bit is that when we have a parameter
                 *   explicitly bound to Object, or an explicit End-Of-List
                 *   flag object, we'll get an undesired side effect of
                 *   this otherwise convenient arrangement: we'll
                 *   effectively bind non-object types to the Object by
                 *   virtue of the inheritance.  To deal with this, we'll
                 *   explicitly set the placeholders' binding to nil in
                 *   this situation - this makes non-object types
                 *   explicitly *not* bound to the function, overriding any
                 *   binding we'd otherwise inherit from Object.  
                 */
                if (typ == nil || typ == '...')
                    typ = Object;

                /* 
                 *   Figure the binding.
                 *   
                 *   - If this is the last parameter, it's the end of the
                 *   line, so bind directly to the function pointer.
                 *   
                 *   - If this isn't the variant parameter, the binding is
                 *   the next binding property.  At invocation, we'll
                 *   continue on to the next argument value, evaluating
                 *   this next property to get its binding in the context
                 *   established by the current argument and property.  The
                 *   next binding property is specific to the current class
                 *   in the current position, so we might already have
                 *   assigned a property for it from another version of
                 *   this function.  Look it up, or create a new one if we
                 *   haven't assigned it already.  
                 */
                local binding;
                if (j == paramCnt)
                {
                    /* end of the line - the binding is the actual function */
                    binding = func;

                    /* 
                     *   if this type is already bound to a different
                     *   definition for this function, we have a
                     *   conflicting definition 
                     */
                    if (typ.propDefined(prop, PropDefDirectly)
                        && typ.(prop) != binding)
                        errs += [baseFunc, func, params, name];
                }
                else
                {
                    /* check for an existing binding property here */
                    if (typ.propDefined(prop, PropDefDirectly))
                    {
                        /* we already have a forward binding here - use it */
                        binding = typ.(prop);
                    }
                    else
                    {
                        /* it's not defined here, so create a new property */
                        binding = t3AllocProp();
                    }
                }

                /* set the binding */
                typ.(prop) = binding;
                
                /*
                 *   As we mentioned above, if the original type is
                 *   explicitly Object, we *don't* want to allow non-object
                 *   types (int, true, nil, property pointers, etc) and
                 *   End-Of-List placeholders to match - without some kind
                 *   of explicit intervention here, the placeholders would
                 *   match by inheritance because the placeholders are just
                 *   objects themselves.  To handle this properly, set the
                 *   non-object placeholder bindings explicitly to nil.  
                 */
                if (origTyp == Object)
                    _MultiMethodPlaceholder.(prop) = nil;

                /* 
                 *   if there's another argument, this binding is the
                 *   binding property for the next argument 
                 */
                prop = binding;
            }
        }
    });

#ifdef MULTMETH_STATIC_INHERITED
    /*
     *   If we're operating in static inheritance mode, cache the
     *   next-override information for inherited() calls.  Since we're
     *   using static inheritance, we can figure this at startup and just
     *   look up the cached information whenever we need to perform an
     *   inherited() call.  
     */
    _multiMethodRegistry.funcTab_.forEachAssoc(new function(baseFunc, val)
    {
        /* get the binding property for the base function */
        local prop = _multiMethodRegistry.boundFuncTab_[baseFunc];

        /* run through the functions registered under this function name */
        for (local i = 1 ; i <= val.length() ; i++)
        {
            /* get this function binding and the type list */
            local func = val[i][1];
            local params = val[i][2];
            local paramCnt = params.length();

            /* 
             *   Add the end-of-list marker if applicable.  For a varargs
             *   function, add one generic Object parameter in place of the
             *   variable list - but we'll check later to make sure that
             *   any match we find is really varargs, since a varargs
             *   function can only inherit from another varargs function.
             *   (This is because, in order to actually invoke the
             *   inherited function from an overrider, the callee must be
             *   varargs to be able to handle varargs from the caller.)  
             */
            local varargs = (paramCnt != 0 && params[paramCnt] == '...');
            if (varargs)
                params[paramCnt] = Object;
            else
                params += _multiMethodEndOfList;

            /* look up the inherited version of the method */
            local inh = _multiMethodInherit(func, prop, params);

            /* varargs can only inherit from varargs */
            if (inh != nil && varargs)
            {
                /* look up the inherited parameters */
                local inhParams = _multiMethodRegistry.funcParamTab_[inh];
                local inhParamCnt = inhParams.length();

                /* make sure it's varargs, too */
                if (inhParamCnt == 0 || inhParams[inhParamCnt] != '...')
                    inh = nil;
            }

            /* remember the inherited function */
            _multiMethodRegistry.inhTab_[func] = inh;
        }
    });
#endif /* MULTMETH_STATIC_INHERITED */
    
    /* we're done with the source bindings - discard them to save memory */
    _multiMethodRegistry.funcTab_ = nil;
    _multiMethodRegistry.funcParamTab_ = nil;
}

/*
 *   Multi-method registry.  This is where we keep the registry information
 *   that we build during initialization.  
 */
_multiMethodRegistry: object
    /* table of registered functions, indexed by base function */
    funcTab_ = static new LookupTable(128, 256)

    /* table of function parameter lists, indexed by function */
    funcParamTab_ = static new LookupTable(128, 256)

    /* function name table */
    funcNameTab_ = static new LookupTable(64, 128)

    /* base function -> initial binding property */
    boundFuncTab_ = static new LookupTable(64, 128)

    /* function -> base function */
    baseFuncTab_ = static new LookupTable(64, 128)

#ifdef MULTMETH_STATIC_INHERITED
    /* table of cached inherited() information, indexed by function */
    inhTab_ = static new LookupTable(64, 128)
#endif
;
