import importlib
import importlib.abc
import importlib.util
import os
import platform
import re
import string
import sys
from tkinter import *
import tkinter.simpledialog as tkSimpleDialog
import tkinter.messagebox as tkMessageBox
import traceback
import webbrowser

from idlelib.MultiCall import MultiCallCreator
from idlelib import WindowList
from idlelib import SearchDialog
from idlelib import GrepDialog
from idlelib import ReplaceDialog
from idlelib import PyParse
from idlelib.configHandler import idleConf
from idlelib import aboutDialog, textView, configDialog
from idlelib import macosxSupport
from idlelib import help

# The default tab setting for a Text widget, in average-width characters.
TK_TABWIDTH_DEFAULT = 8

_py_version = ' (%s)' % platform.python_version()

def _sphinx_version():
    "Format sys.version_info to produce the Sphinx version string used to install the chm docs"
    major, minor, micro, level, serial = sys.version_info
    release = '%s%s' % (major, minor)
    release += '%s' % (micro,)
    if level == 'candidate':
        release += 'rc%s' % (serial,)
    elif level != 'final':
        release += '%s%s' % (level[0], serial)
    return release


class HelpDialog(object):

    def __init__(self):
        self.parent = None      # parent of help window
        self.dlg = None         # the help window iteself

    def display(self, parent, near=None):
        """ Display the help dialog.

            parent - parent widget for the help window

            near - a Toplevel widget (e.g. EditorWindow or PyShell)
                   to use as a reference for placing the help window
        """
        import warnings as w
        w.warn("EditorWindow.HelpDialog is no longer used by Idle.\n"
               "It will be removed in 3.6 or later.\n"
               "It has been replaced by private help.HelpWindow\n",
               DeprecationWarning, stacklevel=2)
        if self.dlg is None:
            self.show_dialog(parent)
        if near:
            self.nearwindow(near)

    def show_dialog(self, parent):
        self.parent = parent
        fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),'help.txt')
        self.dlg = dlg = textView.view_file(parent,'Help',fn, modal=False)
        dlg.bind('<Destroy>', self.destroy, '+')

    def nearwindow(self, near):
        # Place the help dialog near the window specified by parent.
        # Note - this may not reposition the window in Metacity
        #  if "/apps/metacity/general/disable_workarounds" is enabled
        dlg = self.dlg
        geom = (near.winfo_rootx() + 10, near.winfo_rooty() + 10)
        dlg.withdraw()
        dlg.geometry("=+%d+%d" % geom)
        dlg.deiconify()
        dlg.lift()

    def destroy(self, ev=None):
        self.dlg = None
        self.parent = None

helpDialog = HelpDialog()  # singleton instance, no longer used


class EditorWindow(object):
    from idlelib.Percolator import Percolator
    from idlelib.ColorDelegator import ColorDelegator
    from idlelib.UndoDelegator import UndoDelegator
    from idlelib.IOBinding import IOBinding, filesystemencoding, encoding
    from idlelib import Bindings
    from tkinter import Toplevel
    from idlelib.MultiStatusBar import MultiStatusBar

    help_url = None

    def __init__(self, flist=None, filename=None, key=None, root=None):
        if EditorWindow.help_url is None:
            dochome =  os.path.join(sys.base_prefix, 'Doc', 'index.html')
            if sys.platform.count('linux'):
                # look for html docs in a couple of standard places
                pyver = 'python-docs-' + '%s.%s.%s' % sys.version_info[:3]
                if os.path.isdir('/var/www/html/python/'):  # "python2" rpm
                    dochome = '/var/www/html/python/index.html'
                else:
                    basepath = '/usr/share/doc/'  # standard location
                    dochome = os.path.join(basepath, pyver,
                                           'Doc', 'index.html')
            elif sys.platform[:3] == 'win':
                chmfile = os.path.join(sys.base_prefix, 'Doc',
                                       'Python%s.chm' % _sphinx_version())
                if os.path.isfile(chmfile):
                    dochome = chmfile
            elif sys.platform == 'darwin':
                # documentation may be stored inside a python framework
                dochome = os.path.join(sys.base_prefix,
                        'Resources/English.lproj/Documentation/index.html')
            dochome = os.path.normpath(dochome)
            if os.path.isfile(dochome):
                EditorWindow.help_url = dochome
                if sys.platform == 'darwin':
                    # Safari requires real file:-URLs
                    EditorWindow.help_url = 'file://' + EditorWindow.help_url
            else:
                EditorWindow.help_url = "https://docs.python.org/%d.%d/" % sys.version_info[:2]
        self.flist = flist
        root = root or flist.root
        self.root = root
        try:
            sys.ps1
        except AttributeError:
            sys.ps1 = '>>> '
        self.menubar = Menu(root)
        self.top = top = WindowList.ListedToplevel(root, menu=self.menubar)
        if flist:
            self.tkinter_vars = flist.vars
            #self.top.instance_dict makes flist.inversedict available to
            #configDialog.py so it can access all EditorWindow instances
            self.top.instance_dict = flist.inversedict
        else:
            self.tkinter_vars = {}  # keys: Tkinter event names
                                    # values: Tkinter variable instances
            self.top.instance_dict = {}
        self.recent_files_path = os.path.join(idleConf.GetUserCfgDir(),
                'recent-files.lst')
        self.text_frame = text_frame = Frame(top)
        self.vbar = vbar = Scrollbar(text_frame, name='vbar')
        self.width = idleConf.GetOption('main', 'EditorWindow',
                                        'width', type='int')
        text_options = {
                'name': 'text',
                'padx': 5,
                'wrap': 'none',
                'width': self.width,
                'height': idleConf.GetOption('main', 'EditorWindow',
                                             'height', type='int')}
        if TkVersion >= 8.5:
            # Starting with tk 8.5 we have to set the new tabstyle option
            # to 'wordprocessor' to achieve the same display of tabs as in
            # older tk versions.
            text_options['tabstyle'] = 'wordprocessor'
        self.text = text = MultiCallCreator(Text)(text_frame, **text_options)
        self.top.focused_widget = self.text

        self.createmenubar()
        self.apply_bindings()

        self.top.protocol("WM_DELETE_WINDOW", self.close)
        self.top.bind("<<close-window>>", self.close_event)
        if macosxSupport.isAquaTk():
            # Command-W on editorwindows doesn't work without this.
            text.bind('<<close-window>>', self.close_event)
            # Some OS X systems have only one mouse button, so use
            # control-click for popup context menus there. For two
            # buttons, AquaTk defines <2> as the right button, not <3>.
            text.bind("<Control-Button-1>",self.right_menu_event)
            text.bind("<2>", self.right_menu_event)
        else:
            # Elsewhere, use right-click for popup menus.
            text.bind("<3>",self.right_menu_event)
        text.bind("<<cut>>", self.cut)
        text.bind("<<copy>>", self.copy)
        text.bind("<<paste>>", self.paste)
        text.bind("<<center-insert>>", self.center_insert_event)
        text.bind("<<help>>", self.help_dialog)
        text.bind("<<python-docs>>", self.python_docs)
        text.bind("<<about-idle>>", self.about_dialog)
        text.bind("<<open-config-dialog>>", self.config_dialog)
        text.bind("<<open-config-extensions-dialog>>",
                  self.config_extensions_dialog)
        text.bind("<<open-module>>", self.open_module)
        text.bind("<<do-nothing>>", lambda event: "break")
        text.bind("<<select-all>>", self.select_all)
        text.bind("<<remove-selection>>", self.remove_selection)
        text.bind("<<find>>", self.find_event)
        text.bind("<<find-again>>", self.find_again_event)
        text.bind("<<find-in-files>>", self.find_in_files_event)
        text.bind("<<find-selection>>", self.find_selection_event)
        text.bind("<<replace>>", self.replace_event)
        text.bind("<<goto-line>>", self.goto_line_event)
        text.bind("<<smart-backspace>>",self.smart_backspace_event)
        text.bind("<<newline-and-indent>>",self.newline_and_indent_event)
        text.bind("<<smart-indent>>",self.smart_indent_event)
        text.bind("<<indent-region>>",self.indent_region_event)
        text.bind("<<dedent-region>>",self.dedent_region_event)
        text.bind("<<comment-region>>",self.comment_region_event)
        text.bind("<<uncomment-region>>",self.uncomment_region_event)
        text.bind("<<tabify-region>>",self.tabify_region_event)
        text.bind("<<untabify-region>>",self.untabify_region_event)
        text.bind("<<toggle-tabs>>",self.toggle_tabs_event)
        text.bind("<<change-indentwidth>>",self.change_indentwidth_event)
        text.bind("<Left>", self.move_at_edge_if_selection(0))
        text.bind("<Right>", self.move_at_edge_if_selection(1))
        text.bind("<<del-word-left>>", self.del_word_left)
        text.bind("<<del-word-right>>", self.del_word_right)
        text.bind("<<beginning-of-line>>", self.home_callback)

        if flist:
            flist.inversedict[self] = key
            if key:
                flist.dict[key] = self
            text.bind("<<open-new-window>>", self.new_callback)
            text.bind("<<close-all-windows>>", self.flist.close_all_callback)
            text.bind("<<open-class-browser>>", self.open_class_browser)
            text.bind("<<open-path-browser>>", self.open_path_browser)
            text.bind("<<open-turtle-demo>>", self.open_turtle_demo)

        self.set_status_bar()
        vbar['command'] = text.yview
        vbar.pack(side=RIGHT, fill=Y)
        text['yscrollcommand'] = vbar.set
        text['font'] = idleConf.GetFont(self.root, 'main', 'EditorWindow')
        text_frame.pack(side=LEFT, fill=BOTH, expand=1)
        text.pack(side=TOP, fill=BOTH, expand=1)
        text.focus_set()

        # usetabs true  -> literal tab characters are used by indent and
        #                  dedent cmds, possibly mixed with spaces if
        #                  indentwidth is not a multiple of tabwidth,
        #                  which will cause Tabnanny to nag!
        #         false -> tab characters are converted to spaces by indent
        #                  and dedent cmds, and ditto TAB keystrokes
        # Although use-spaces=0 can be configured manually in config-main.def,
        # configuration of tabs v. spaces is not supported in the configuration
        # dialog.  IDLE promotes the preferred Python indentation: use spaces!
        usespaces = idleConf.GetOption('main', 'Indent',
                                       'use-spaces', type='bool')
        self.usetabs = not usespaces

        # tabwidth is the display width of a literal tab character.
        # CAUTION:  telling Tk to use anything other than its default
        # tab setting causes it to use an entirely different tabbing algorithm,
        # treating tab stops as fixed distances from the left margin.
        # Nobody expects this, so for now tabwidth should never be changed.
        self.tabwidth = 8    # must remain 8 until Tk is fixed.

        # indentwidth is the number of screen characters per indent level.
        # The recommended Python indentation is four spaces.
        self.indentwidth = self.tabwidth
        self.set_notabs_indentwidth()

        # If context_use_ps1 is true, parsing searches back for a ps1 line;
        # else searches for a popular (if, def, ...) Python stmt.
        self.context_use_ps1 = False

        # When searching backwards for a reliable place to begin parsing,
        # first start num_context_lines[0] lines back, then
        # num_context_lines[1] lines back if that didn't work, and so on.
        # The last value should be huge (larger than the # of lines in a
        # conceivable file).
        # Making the initial values larger slows things down more often.
        self.num_context_lines = 50, 500, 5000000
        self.per = per = self.Percolator(text)
        self.undo = undo = self.UndoDelegator()
        per.insertfilter(undo)
        text.undo_block_start = undo.undo_block_start
        text.undo_block_stop = undo.undo_block_stop
        undo.set_saved_change_hook(self.saved_change_hook)
        # IOBinding implements file I/O and printing functionality
        self.io = io = self.IOBinding(self)
        io.set_filename_change_hook(self.filename_change_hook)
        self.good_load = False
        self.set_indentation_params(False)
        self.color = None # initialized below in self.ResetColorizer
        if filename:
            if os.path.exists(filename) and not os.path.isdir(filename):
                if io.loadfile(filename):
                    self.good_load = True
                    is_py_src = self.ispythonsource(filename)
                    self.set_indentation_params(is_py_src)
            else:
                io.set_filename(filename)
                self.good_load = True

        self.ResetColorizer()
        self.saved_change_hook()
        self.update_recent_files_list()
        self.load_extensions()
        menu = self.menudict.get('windows')
        if menu:
            end = menu.index("end")
            if end is None:
                end = -1
            if end >= 0:
                menu.add_separator()
                end = end + 1
            self.wmenu_end = end
            WindowList.register_callback(self.postwindowsmenu)

        # Some abstractions so IDLE extensions are cross-IDE
        self.askyesno = tkMessageBox.askyesno
        self.askinteger = tkSimpleDialog.askinteger
        self.showerror = tkMessageBox.showerror

        self._highlight_workaround()  # Fix selection tags on Windows

    def _highlight_workaround(self):
        # On Windows, Tk removes painting of the selection
        # tags which is different behavior than on Linux and Mac.
        # See issue14146 for more information.
        if not sys.platform.startswith('win'):
            return

        text = self.text
        text.event_add("<<Highlight-FocusOut>>", "<FocusOut>")
        text.event_add("<<Highlight-FocusIn>>", "<FocusIn>")
        def highlight_fix(focus):
            sel_range = text.tag_ranges("sel")
            if sel_range:
                if focus == 'out':
                    HILITE_CONFIG = idleConf.GetHighlight(
                            idleConf.CurrentTheme(), 'hilite')
                    text.tag_config("sel_fix", HILITE_CONFIG)
                    text.tag_raise("sel_fix")
                    text.tag_add("sel_fix", *sel_range)
                elif focus == 'in':
                    text.tag_remove("sel_fix", "1.0", "end")

        text.bind("<<Highlight-FocusOut>>",
                lambda ev: highlight_fix("out"))
        text.bind("<<Highlight-FocusIn>>",
                lambda ev: highlight_fix("in"))


    def _filename_to_unicode(self, filename):
        """Return filename as BMP unicode so diplayable in Tk."""
        # Decode bytes to unicode.
        if isinstance(filename, bytes):
            try:
                filename = filename.decode(self.filesystemencoding)
            except UnicodeDecodeError:
                try:
                    filename = filename.decode(self.encoding)
                except UnicodeDecodeError:
                    # byte-to-byte conversion
                    filename = filename.decode('iso8859-1')
        # Replace non-BMP char with diamond questionmark.
        return re.sub('[\U00010000-\U0010FFFF]', '\ufffd', filename)

    def new_callback(self, event):
        dirname, basename = self.io.defaultfilename()
        self.flist.new(dirname)
        return "break"

    def home_callback(self, event):
        if (event.state & 4) != 0 and event.keysym == "Home":
            # state&4==Control. If <Control-Home>, use the Tk binding.
            return
        if self.text.index("iomark") and \
           self.text.compare("iomark", "<=", "insert lineend") and \
           self.text.compare("insert linestart", "<=", "iomark"):
            # In Shell on input line, go to just after prompt
            insertpt = int(self.text.index("iomark").split(".")[1])
        else:
            line = self.text.get("insert linestart", "insert lineend")
            for insertpt in range(len(line)):
                if line[insertpt] not in (' ','\t'):
                    break
            else:
                insertpt=len(line)
        lineat = int(self.text.index("insert").split('.')[1])
        if insertpt == lineat:
            insertpt = 0
        dest = "insert linestart+"+str(insertpt)+"c"
        if (event.state&1) == 0:
            # shift was not pressed
            self.text.tag_remove("sel", "1.0", "end")
        else:
            if not self.text.index("sel.first"):
                # there was no previous selection
                self.text.mark_set("my_anchor", "insert")
            else:
                if self.text.compare(self.text.index("sel.first"), "<",
                                     self.text.index("insert")):
                    self.text.mark_set("my_anchor", "sel.first") # extend back
                else:
                    self.text.mark_set("my_anchor", "sel.last") # extend forward
            first = self.text.index(dest)
            last = self.text.index("my_anchor")
            if self.text.compare(first,">",last):
                first,last = last,first
            self.text.tag_remove("sel", "1.0", "end")
            self.text.tag_add("sel", first, last)
        self.text.mark_set("insert", dest)
        self.text.see("insert")
        return "break"

    def set_status_bar(self):
        self.status_bar = self.MultiStatusBar(self.top)
        if sys.platform == "darwin":
            # Insert some padding to avoid obscuring some of the statusbar
            # by the resize widget.
            self.status_bar.set_label('_padding1', '    ', side=RIGHT)
        self.status_bar.set_label('column', 'Col: ?', side=RIGHT)
        self.status_bar.set_label('line', 'Ln: ?', side=RIGHT)
        self.status_bar.pack(side=BOTTOM, fill=X)
        self.text.bind("<<set-line-and-column>>", self.set_line_and_column)
        self.text.event_add("<<set-line-and-column>>",
                            "<KeyRelease>", "<ButtonRelease>")
        self.text.after_idle(self.set_line_and_column)

    def set_line_and_column(self, event=None):
        line, column = self.text.index(INSERT).split('.')
        self.status_bar.set_label('column', 'Col: %s' % column)
        self.status_bar.set_label('line', 'Ln: %s' % line)

    menu_specs = [
        ("file", "_File"),
        ("edit", "_Edit"),
        ("format", "F_ormat"),
        ("run", "_Run"),
        ("options", "_Options"),
        ("windows", "_Window"),
        ("help", "_Help"),
    ]


    def createmenubar(self):
        mbar = self.menubar
        self.menudict = menudict = {}
        for name, label in self.menu_specs:
            underline, label = prepstr(label)
            menudict[name] = menu = Menu(mbar, name=name, tearoff=0)
            mbar.add_cascade(label=label, menu=menu, underline=underline)
        if macosxSupport.isCarbonTk():
            # Insert the application menu
            menudict['application'] = menu = Menu(mbar, name='apple',
                                                  tearoff=0)
            mbar.add_cascade(label='IDLE', menu=menu)
        self.fill_menus()
        self.recent_files_menu = Menu(self.menubar, tearoff=0)
        self.menudict['file'].insert_cascade(3, label='Recent Files',
                                             underline=0,
                                             menu=self.recent_files_menu)
        self.base_helpmenu_length = self.menudict['help'].index(END)
        self.reset_help_menu_entries()

    def postwindowsmenu(self):
        # Only called when Windows menu exists
        menu = self.menudict['windows']
        end = menu.index("end")
        if end is None:
            end = -1
        if end > self.wmenu_end:
            menu.delete(self.wmenu_end+1, end)
        WindowList.add_windows_to_menu(menu)

    rmenu = None

    def right_menu_event(self, event):
        self.text.mark_set("insert", "@%d,%d" % (event.x, event.y))
        if not self.rmenu:
            self.make_rmenu()
        rmenu = self.rmenu
        self.event = event
        iswin = sys.platform[:3] == 'win'
        if iswin:
            self.text.config(cursor="arrow")

        for item in self.rmenu_specs:
            try:
                label, eventname, verify_state = item
            except ValueError: # see issue1207589
                continue

            if verify_state is None:
                continue
            state = getattr(self, verify_state)()
            rmenu.entryconfigure(label, state=state)


        rmenu.tk_popup(event.x_root, event.y_root)
        if iswin:
            self.text.config(cursor="ibeam")

    rmenu_specs = [
        # ("Label", "<<virtual-event>>", "statefuncname"), ...
        ("Close", "<<close-window>>", None), # Example
    ]

    def make_rmenu(self):
        rmenu = Menu(self.text, tearoff=0)
        for item in self.rmenu_specs:
            label, eventname = item[0], item[1]
            if label is not None:
                def command(text=self.text, eventname=eventname):
                    text.event_generate(eventname)
                rmenu.add_command(label=label, command=command)
            else:
                rmenu.add_separator()
        self.rmenu = rmenu

    def rmenu_check_cut(self):
        return self.rmenu_check_copy()

    def rmenu_check_copy(self):
        try:
            indx = self.text.index('sel.first')
        except TclError:
            return 'disabled'
        else:
            return 'normal' if indx else 'disabled'

    def rmenu_check_paste(self):
        try:
            self.text.tk.call('tk::GetSelection', self.text, 'CLIPBOARD')
        except TclError:
            return 'disabled'
        else:
            return 'normal'

    def about_dialog(self, event=None):
        "Handle Help 'About IDLE' event."
        # Synchronize with macosxSupport.overrideRootMenu.about_dialog.
        aboutDialog.AboutDialog(self.top,'About IDLE')

    def config_dialog(self, event=None):
        "Handle Options 'Configure IDLE' event."
        # Synchronize with macosxSupport.overrideRootMenu.config_dialog.
        configDialog.ConfigDialog(self.top,'Settings')

    def config_extensions_dialog(self, event=None):
        "Handle Options 'Configure Extensions' event."
        configDialog.ConfigExtensionsDialog(self.top)

    def help_dialog(self, event=None):
        "Handle Help 'IDLE Help' event."
        # Synchronize with macosxSupport.overrideRootMenu.help_dialog.
        if self.root:
            parent = self.root
        else:
            parent = self.top
        help.show_idlehelp(parent)

    def python_docs(self, event=None):
        if sys.platform[:3] == 'win':
            try:
                os.startfile(self.help_url)
            except OSError as why:
                tkMessageBox.showerror(title='Document Start Failure',
                    message=str(why), parent=self.text)
        else:
            webbrowser.open(self.help_url)
        return "break"

    def cut(self,event):
        self.text.event_generate("<<Cut>>")
        return "break"

    def copy(self,event):
        if not self.text.tag_ranges("sel"):
            # There is no selection, so do nothing and maybe interrupt.
            return
        self.text.event_generate("<<Copy>>")
        return "break"

    def paste(self,event):
        self.text.event_generate("<<Paste>>")
        self.text.see("insert")
        return "break"

    def select_all(self, event=None):
        self.text.tag_add("sel", "1.0", "end-1c")
        self.text.mark_set("insert", "1.0")
        self.text.see("insert")
        return "break"

    def remove_selection(self, event=None):
        self.text.tag_remove("sel", "1.0", "end")
        self.text.see("insert")

    def move_at_edge_if_selection(self, edge_index):
        """Cursor move begins at start or end of selection

        When a left/right cursor key is pressed create and return to Tkinter a
        function which causes a cursor move from the associated edge of the
        selection.

        """
        self_text_index = self.text.index
        self_text_mark_set = self.text.mark_set
        edges_table = ("sel.first+1c", "sel.last-1c")
        def move_at_edge(event):
            if (event.state & 5) == 0: # no shift(==1) or control(==4) pressed
                try:
                    self_text_index("sel.first")
                    self_text_mark_set("insert", edges_table[edge_index])
                except TclError:
                    pass
        return move_at_edge

    def del_word_left(self, event):
        self.text.event_generate('<Meta-Delete>')
        return "break"

    def del_word_right(self, event):
        self.text.event_generate('<Meta-d>')
        return "break"

    def find_event(self, event):
        SearchDialog.find(self.text)
        return "break"

    def find_again_event(self, event):
        SearchDialog.find_again(self.text)
        return "break"

    def find_selection_event(self, event):
        SearchDialog.find_selection(self.text)
        return "break"

    def find_in_files_event(self, event):
        GrepDialog.grep(self.text, self.io, self.flist)
        return "break"

    def replace_event(self, event):
        ReplaceDialog.replace(self.text)
        return "break"

    def goto_line_event(self, event):
        text = self.text
        lineno = tkSimpleDialog.askinteger("Goto",
                "Go to line number:",parent=text)
        if lineno is None:
            return "break"
        if lineno <= 0:
            text.bell()
            return "break"
        text.mark_set("insert", "%d.0" % lineno)
        text.see("insert")

    def open_module(self, event=None):
        # XXX Shouldn't this be in IOBinding?
        try:
            name = self.text.get("sel.first", "sel.last")
        except TclError:
            name = ""
        else:
            name = name.strip()
        name = tkSimpleDialog.askstring("Module",
                 "Enter the name of a Python module\n"
                 "to search on sys.path and open:",
                 parent=self.text, initialvalue=name)
        if name:
            name = name.strip()
        if not name:
            return
        # XXX Ought to insert current file's directory in front of path
        try:
            spec = importlib.util.find_spec(name)
        except (ValueError, ImportError) as msg:
            tkMessageBox.showerror("Import error", str(msg), parent=self.text)
            return
        if spec is None:
            tkMessageBox.showerror("Import error", "module not found",
                                   parent=self.text)
            return
        if not isinstance(spec.loader, importlib.abc.SourceLoader):
            tkMessageBox.showerror("Import error", "not a source-based module",
                                   parent=self.text)
            return
        try:
            file_path = spec.loader.get_filename(name)
        except AttributeError:
            tkMessageBox.showerror("Import error",
                                   "loader does not support get_filename",
                                   parent=self.text)
            return
        if self.flist:
            self.flist.open(file_path)
        else:
            self.io.loadfile(file_path)
        return file_path

    def open_class_browser(self, event=None):
        filename = self.io.filename
        if not (self.__class__.__name__ == 'PyShellEditorWindow'
                and filename):
            filename = self.open_module()
            if filename is None:
                return
        head, tail = os.path.split(filename)
        base, ext = os.path.splitext(tail)
        from idlelib import ClassBrowser
        ClassBrowser.ClassBrowser(self.flist, base, [head])

    def open_path_browser(self, event=None):
        from idlelib import PathBrowser
        PathBrowser.PathBrowser(self.flist)

    def open_turtle_demo(self, event = None):
        import subprocess

        cmd = [sys.executable,
               '-c',
               'from turtledemo.__main__ import main; main()']
        subprocess.Popen(cmd, shell=False)

    def gotoline(self, lineno):
        if lineno is not None and lineno > 0:
            self.text.mark_set("insert", "%d.0" % lineno)
            self.text.tag_remove("sel", "1.0", "end")
            self.text.tag_add("sel", "insert", "insert +1l")
            self.center()

    def ispythonsource(self, filename):
        if not filename or os.path.isdir(filename):
            return True
        base, ext = os.path.splitext(os.path.basename(filename))
        if os.path.normcase(ext) in (".py", ".pyw"):
            return True
        line = self.text.get('1.0', '1.0 lineend')
        return line.startswith('#!') and 'python' in line

    def close_hook(self):
        if self.flist:
            self.flist.unregister_maybe_terminate(self)
            self.flist = None

    def set_close_hook(self, close_hook):
        self.close_hook = close_hook

    def filename_change_hook(self):
        if self.flist:
            self.flist.filename_changed_edit(self)
        self.saved_change_hook()
        self.top.update_windowlist_registry(self)
        self.ResetColorizer()

    def _addcolorizer(self):
        if self.color:
            return
        if self.ispythonsource(self.io.filename):
            self.color = self.ColorDelegator()
        # can add more colorizers here...
        if self.color:
            self.per.removefilter(self.undo)
            self.per.insertfilter(self.color)
            self.per.insertfilter(self.undo)

    def _rmcolorizer(self):
        if not self.color:
            return
        self.color.removecolors()
        self.per.removefilter(self.color)
        self.color = None

    def ResetColorizer(self):
        "Update the color theme"
        # Called from self.filename_change_hook and from configDialog.py
        self._rmcolorizer()
        self._addcolorizer()
        theme = idleConf.GetOption('main','Theme','name')
        normal_colors = idleConf.GetHighlight(theme, 'normal')
        cursor_color = idleConf.GetHighlight(theme, 'cursor', fgBg='fg')
        select_colors = idleConf.GetHighlight(theme, 'hilite')
        self.text.config(
            foreground=normal_colors['foreground'],
            background=normal_colors['background'],
            insertbackground=cursor_color,
            selectforeground=select_colors['foreground'],
            selectbackground=select_colors['background'],
            )

    IDENTCHARS = string.ascii_letters + string.digits + "_"

    def colorize_syntax_error(self, text, pos):
        text.tag_add("ERROR", pos)
        char = text.get(pos)
        if char and char in self.IDENTCHARS:
            text.tag_add("ERROR", pos + " wordstart", pos)
        if '\n' == text.get(pos):   # error at line end
            text.mark_set("insert", pos)
        else:
            text.mark_set("insert", pos + "+1c")
        text.see(pos)

    def ResetFont(self):
        "Update the text widgets' font if it is changed"
        # Called from configDialog.py

        self.text['font'] = idleConf.GetFont(self.root, 'main','EditorWindow')

    def RemoveKeybindings(self):
        "Remove the keybindings before they are changed."
        # Called from configDialog.py
        self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
        for event, keylist in keydefs.items():
            self.text.event_delete(event, *keylist)
        for extensionName in self.get_standard_extension_names():
            xkeydefs = idleConf.GetExtensionBindings(extensionName)
            if xkeydefs:
                for event, keylist in xkeydefs.items():
                    self.text.event_delete(event, *keylist)

    def ApplyKeybindings(self):
        "Update the keybindings after they are changed"
        # Called from configDialog.py
        self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
        self.apply_bindings()
        for extensionName in self.get_standard_extension_names():
            xkeydefs = idleConf.GetExtensionBindings(extensionName)
            if xkeydefs:
                self.apply_bindings(xkeydefs)
        #update menu accelerators
        menuEventDict = {}
        for menu in self.Bindings.menudefs:
            menuEventDict[menu[0]] = {}
            for item in menu[1]:
                if item:
                    menuEventDict[menu[0]][prepstr(item[0])[1]] = item[1]
        for menubarItem in self.menudict:
            menu = self.menudict[menubarItem]
            end = menu.index(END)
            if end is None:
                # Skip empty menus
                continue
            end += 1
            for index in range(0, end):
                if menu.type(index) == 'command':
                    accel = menu.entrycget(index, 'accelerator')
                    if accel:
                        itemName = menu.entrycget(index, 'label')
                        event = ''
                        if menubarItem in menuEventDict:
                            if itemName in menuEventDict[menubarItem]:
                                event = menuEventDict[menubarItem][itemName]
                        if event:
                            accel = get_accelerator(keydefs, event)
                            menu.entryconfig(index, accelerator=accel)

    def set_notabs_indentwidth(self):
        "Update the indentwidth if changed and not using tabs in this window"
        # Called from configDialog.py
        if not self.usetabs:
            self.indentwidth = idleConf.GetOption('main', 'Indent','num-spaces',
                                                  type='int')

    def reset_help_menu_entries(self):
        "Update the additional help entries on the Help menu"
        help_list = idleConf.GetAllExtraHelpSourcesList()
        helpmenu = self.menudict['help']
        # first delete the extra help entries, if any
        helpmenu_length = helpmenu.index(END)
        if helpmenu_length > self.base_helpmenu_length:
            helpmenu.delete((self.base_helpmenu_length + 1), helpmenu_length)
        # then rebuild them
        if help_list:
            helpmenu.add_separator()
            for entry in help_list:
                cmd = self.__extra_help_callback(entry[1])
                helpmenu.add_command(label=entry[0], command=cmd)
        # and update the menu dictionary
        self.menudict['help'] = helpmenu

    def __extra_help_callback(self, helpfile):
        "Create a callback with the helpfile value frozen at definition time"
        def display_extra_help(helpfile=helpfile):
            if not helpfile.startswith(('www', 'http')):
                helpfile = os.path.normpath(helpfile)
            if sys.platform[:3] == 'win':
                try:
                    os.startfile(helpfile)
                except OSError as why:
                    tkMessageBox.showerror(title='Document Start Failure',
                        message=str(why), parent=self.text)
            else:
                webbrowser.open(helpfile)
        return display_extra_help

    def update_recent_files_list(self, new_file=None):
        "Load and update the recent files list and menus"
        rf_list = []
        if os.path.exists(self.recent_files_path):
            with open(self.recent_files_path, 'r',
                      encoding='utf_8', errors='replace') as rf_list_file:
                rf_list = rf_list_file.readlines()
        if new_file:
            new_file = os.path.abspath(new_file) + '\n'
            if new_file in rf_list:
                rf_list.remove(new_file)  # move to top
            rf_list.insert(0, new_file)
        # clean and save the recent files list
        bad_paths = []
        for path in rf_list:
            if '\0' in path or not os.path.exists(path[0:-1]):
                bad_paths.append(path)
        rf_list = [path for path in rf_list if path not in bad_paths]
        ulchars = "1234567890ABCDEFGHIJK"
        rf_list = rf_list[0:len(ulchars)]
        try:
            with open(self.recent_files_path, 'w',
                        encoding='utf_8', errors='replace') as rf_file:
                rf_file.writelines(rf_list)
        except OSError as err:
            if not getattr(self.root, "recentfilelist_error_displayed", False):
                self.root.recentfilelist_error_displayed = True
                tkMessageBox.showerror(title='IDLE Error',
                    message='Unable to update Recent Files list:\n%s'
                        % str(err),
                    parent=self.text)
        # for each edit window instance, construct the recent files menu
        for instance in self.top.instance_dict:
            menu = instance.recent_files_menu
            menu.delete(0, END)  # clear, and rebuild:
            for i, file_name in enumerate(rf_list):
                file_name = file_name.rstrip()  # zap \n
                # make unicode string to display non-ASCII chars correctly
                ufile_name = self._filename_to_unicode(file_name)
                callback = instance.__recent_file_callback(file_name)
                menu.add_command(label=ulchars[i] + " " + ufile_name,
                                 command=callback,
                                 underline=0)

    def __recent_file_callback(self, file_name):
        def open_recent_file(fn_closure=file_name):
            self.io.open(editFile=fn_closure)
        return open_recent_file

    def saved_change_hook(self):
        short = self.short_title()
        long = self.long_title()
        if short and long:
            title = short + " - " + long + _py_version
        elif short:
            title = short
        elif long:
            title = long
        else:
            title = "Untitled"
        icon = short or long or title
        if not self.get_saved():
            title = "*%s*" % title
            icon = "*%s" % icon
        self.top.wm_title(title)
        self.top.wm_iconname(icon)

    def get_saved(self):
        return self.undo.get_saved()

    def set_saved(self, flag):
        self.undo.set_saved(flag)

    def reset_undo(self):
        self.undo.reset_undo()

    def short_title(self):
        filename = self.io.filename
        if filename:
            filename = os.path.basename(filename)
        else:
            filename = "Untitled"
        # return unicode string to display non-ASCII chars correctly
        return self._filename_to_unicode(filename)

    def long_title(self):
        # return unicode string to display non-ASCII chars correctly
        return self._filename_to_unicode(self.io.filename or "")

    def center_insert_event(self, event):
        self.center()

    def center(self, mark="insert"):
        text = self.text
        top, bot = self.getwindowlines()
        lineno = self.getlineno(mark)
        height = bot - top
        newtop = max(1, lineno - height//2)
        text.yview(float(newtop))

    def getwindowlines(self):
        text = self.text
        top = self.getlineno("@0,0")
        bot = self.getlineno("@0,65535")
        if top == bot and text.winfo_height() == 1:
            # Geometry manager hasn't run yet
            height = int(text['height'])
            bot = top + height - 1
        return top, bot

    def getlineno(self, mark="insert"):
        text = self.text
        return int(float(text.index(mark)))

    def get_geometry(self):
        "Return (width, height, x, y)"
        geom = self.top.wm_geometry()
        m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", geom)
        return list(map(int, m.groups()))

    def close_event(self, event):
        self.close()

    def maybesave(self):
        if self.io:
            if not self.get_saved():
                if self.top.state()!='normal':
                    self.top.deiconify()
                self.top.lower()
                self.top.lift()
            return self.io.maybesave()

    def close(self):
        reply = self.maybesave()
        if str(reply) != "cancel":
            self._close()
        return reply

    def _close(self):
        if self.io.filename:
            self.update_recent_files_list(new_file=self.io.filename)
        WindowList.unregister_callback(self.postwindowsmenu)
        self.unload_extensions()
        self.io.close()
        self.io = None
        self.undo = None
        if self.color:
            self.color.close(False)
            self.color = None
        self.text = None
        self.tkinter_vars = None
        self.per.close()
        self.per = None
        self.top.destroy()
        if self.close_hook:
            # unless override: unregister from flist, terminate if last window
            self.close_hook()

    def load_extensions(self):
        self.extensions = {}
        self.load_standard_extensions()

    def unload_extensions(self):
        for ins in list(self.extensions.values()):
            if hasattr(ins, "close"):
                ins.close()
        self.extensions = {}

    def load_standard_extensions(self):
        for name in self.get_standard_extension_names():
            try:
                self.load_extension(name)
            except:
                print("Failed to load extension", repr(name))
                traceback.print_exc()

    def get_standard_extension_names(self):
        return idleConf.GetExtensions(editor_only=True)

    def load_extension(self, name):
        try:
            try:
                mod = importlib.import_module('.' + name, package=__package__)
            except (ImportError, TypeError):
                mod = importlib.import_module(name)
        except ImportError:
            print("\nFailed to import extension: ", name)
            raise
        cls = getattr(mod, name)
        keydefs = idleConf.GetExtensionBindings(name)
        if hasattr(cls, "menudefs"):
            self.fill_menus(cls.menudefs, keydefs)
        ins = cls(self)
        self.extensions[name] = ins
        if keydefs:
            self.apply_bindings(keydefs)
            for vevent in keydefs:
                methodname = vevent.replace("-", "_")
                while methodname[:1] == '<':
                    methodname = methodname[1:]
                while methodname[-1:] == '>':
                    methodname = methodname[:-1]
                methodname = methodname + "_event"
                if hasattr(ins, methodname):
                    self.text.bind(vevent, getattr(ins, methodname))

    def apply_bindings(self, keydefs=None):
        if keydefs is None:
            keydefs = self.Bindings.default_keydefs
        text = self.text
        text.keydefs = keydefs
        for event, keylist in keydefs.items():
            if keylist:
                text.event_add(event, *keylist)

    def fill_menus(self, menudefs=None, keydefs=None):
        """Add appropriate entries to the menus and submenus

        Menus that are absent or None in self.menudict are ignored.
        """
        if menudefs is None:
            menudefs = self.Bindings.menudefs
        if keydefs is None:
            keydefs = self.Bindings.default_keydefs
        menudict = self.menudict
        text = self.text
        for mname, entrylist in menudefs:
            menu = menudict.get(mname)
            if not menu:
                continue
            for entry in entrylist:
                if not entry:
                    menu.add_separator()
                else:
                    label, eventname = entry
                    checkbutton = (label[:1] == '!')
                    if checkbutton:
                        label = label[1:]
                    underline, label = prepstr(label)
                    accelerator = get_accelerator(keydefs, eventname)
                    def command(text=text, eventname=eventname):
                        text.event_generate(eventname)
                    if checkbutton:
                        var = self.get_var_obj(eventname, BooleanVar)
                        menu.add_checkbutton(label=label, underline=underline,
                            command=command, accelerator=accelerator,
                            variable=var)
                    else:
                        menu.add_command(label=label, underline=underline,
                                         command=command,
                                         accelerator=accelerator)

    def getvar(self, name):
        var = self.get_var_obj(name)
        if var:
            value = var.get()
            return value
        else:
            raise NameError(name)

    def setvar(self, name, value, vartype=None):
        var = self.get_var_obj(name, vartype)
        if var:
            var.set(value)
        else:
            raise NameError(name)

    def get_var_obj(self, name, vartype=None):
        var = self.tkinter_vars.get(name)
        if not var and vartype:
            # create a Tkinter variable object with self.text as master:
            self.tkinter_vars[name] = var = vartype(self.text)
        return var

    # Tk implementations of "virtual text methods" -- each platform
    # reusing IDLE's support code needs to define these for its GUI's
    # flavor of widget.

    # Is character at text_index in a Python string?  Return 0 for
    # "guaranteed no", true for anything else.  This info is expensive
    # to compute ab initio, but is probably already known by the
    # platform's colorizer.

    def is_char_in_string(self, text_index):
        if self.color:
            # Return true iff colorizer hasn't (re)gotten this far
            # yet, or the character is tagged as being in a string
            return self.text.tag_prevrange("TODO", text_index) or \
                   "STRING" in self.text.tag_names(text_index)
        else:
            # The colorizer is missing: assume the worst
            return 1

    # If a selection is defined in the text widget, return (start,
    # end) as Tkinter text indices, otherwise return (None, None)
    def get_selection_indices(self):
        try:
            first = self.text.index("sel.first")
            last = self.text.index("sel.last")
            return first, last
        except TclError:
            return None, None

    # Return the text widget's current view of what a tab stop means
    # (equivalent width in spaces).

    def get_tk_tabwidth(self):
        current = self.text['tabs'] or TK_TABWIDTH_DEFAULT
        return int(current)

    # Set the text widget's current view of what a tab stop means.

    def set_tk_tabwidth(self, newtabwidth):
        text = self.text
        if self.get_tk_tabwidth() != newtabwidth:
            # Set text widget tab width
            pixels = text.tk.call("font", "measure", text["font"],
                                  "-displayof", text.master,
                                  "n" * newtabwidth)
            text.configure(tabs=pixels)

### begin autoindent code ###  (configuration was moved to beginning of class)

    def set_indentation_params(self, is_py_src, guess=True):
        if is_py_src and guess:
            i = self.guess_indent()
            if 2 <= i <= 8:
                self.indentwidth = i
            if self.indentwidth != self.tabwidth:
                self.usetabs = False
        self.set_tk_tabwidth(self.tabwidth)

    def smart_backspace_event(self, event):
        text = self.text
        first, last = self.get_selection_indices()
        if first and last:
            text.delete(first, last)
            text.mark_set("insert", first)
            return "break"
        # Delete whitespace left, until hitting a real char or closest
        # preceding virtual tab stop.
        chars = text.get("insert linestart", "insert")
        if chars == '':
            if text.compare("insert", ">", "1.0"):
                # easy: delete preceding newline
                text.delete("insert-1c")
            else:
                text.bell()     # at start of buffer
            return "break"
        if  chars[-1] not in " \t":
            # easy: delete preceding real char
            text.delete("insert-1c")
            return "break"
        # Ick.  It may require *inserting* spaces if we back up over a
        # tab character!  This is written to be clear, not fast.
        tabwidth = self.tabwidth
        have = len(chars.expandtabs(tabwidth))
        assert have > 0
        want = ((have - 1) // self.indentwidth) * self.indentwidth
        # Debug prompt is multilined....
        if self.context_use_ps1:
            last_line_of_prompt = sys.ps1.split('\n')[-1]
        else:
            last_line_of_prompt = ''
        ncharsdeleted = 0
        while 1:
            if chars == last_line_of_prompt:
                break
            chars = chars[:-1]
            ncharsdeleted = ncharsdeleted + 1
            have = len(chars.expandtabs(tabwidth))
            if have <= want or chars[-1] not in " \t":
                break
        text.undo_block_start()
        text.delete("insert-%dc" % ncharsdeleted, "insert")
        if have < want:
            text.insert("insert", ' ' * (want - have))
        text.undo_block_stop()
        return "break"

    def smart_indent_event(self, event):
        # if intraline selection:
        #     delete it
        # elif multiline selection:
        #     do indent-region
        # else:
        #     indent one level
        text = self.text
        first, last = self.get_selection_indices()
        text.undo_block_start()
        try:
            if first and last:
                if index2line(first) != index2line(last):
                    return self.indent_region_event(event)
                text.delete(first, last)
                text.mark_set("insert", first)
            prefix = text.get("insert linestart", "insert")
            raw, effective = classifyws(prefix, self.tabwidth)
            if raw == len(prefix):
                # only whitespace to the left
                self.reindent_to(effective + self.indentwidth)
            else:
                # tab to the next 'stop' within or to right of line's text:
                if self.usetabs:
                    pad = '\t'
                else:
                    effective = len(prefix.expandtabs(self.tabwidth))
                    n = self.indentwidth
                    pad = ' ' * (n - effective % n)
                text.insert("insert", pad)
            text.see("insert")
            return "break"
        finally:
            text.undo_block_stop()

    def newline_and_indent_event(self, event):
        text = self.text
        first, last = self.get_selection_indices()
        text.undo_block_start()
        try:
            if first and last:
                text.delete(first, last)
                text.mark_set("insert", first)
            line = text.get("insert linestart", "insert")
            i, n = 0, len(line)
            while i < n and line[i] in " \t":
                i = i+1
            if i == n:
                # the cursor is in or at leading indentation in a continuation
                # line; just inject an empty line at the start
                text.insert("insert linestart", '\n')
                return "break"
            indent = line[:i]
            # strip whitespace before insert point unless it's in the prompt
            i = 0
            last_line_of_prompt = sys.ps1.split('\n')[-1]
            while line and line[-1] in " \t" and line != last_line_of_prompt:
                line = line[:-1]
                i = i+1
            if i:
                text.delete("insert - %d chars" % i, "insert")
            # strip whitespace after insert point
            while text.get("insert") in " \t":
                text.delete("insert")
            # start new line
            text.insert("insert", '\n')

            # adjust indentation for continuations and block
            # open/close first need to find the last stmt
            lno = index2line(text.index('insert'))
            y = PyParse.Parser(self.indentwidth, self.tabwidth)
            if not self.context_use_ps1:
                for context in self.num_context_lines:
                    startat = max(lno - context, 1)
                    startatindex = repr(startat) + ".0"
                    rawtext = text.get(startatindex, "insert")
                    y.set_str(rawtext)
                    bod = y.find_good_parse_start(
                              self.context_use_ps1,
                              self._build_char_in_string_func(startatindex))
                    if bod is not None or startat == 1:
                        break
                y.set_lo(bod or 0)
            else:
                r = text.tag_prevrange("console", "insert")
                if r:
                    startatindex = r[1]
                else:
                    startatindex = "1.0"
                rawtext = text.get(startatindex, "insert")
                y.set_str(rawtext)
                y.set_lo(0)

            c = y.get_continuation_type()
            if c != PyParse.C_NONE:
                # The current stmt hasn't ended yet.
                if c == PyParse.C_STRING_FIRST_LINE:
                    # after the first line of a string; do not indent at all
                    pass
                elif c == PyParse.C_STRING_NEXT_LINES:
                    # inside a string which started before this line;
                    # just mimic the current indent
                    text.insert("insert", indent)
                elif c == PyParse.C_BRACKET:
                    # line up with the first (if any) element of the
                    # last open bracket structure; else indent one
                    # level beyond the indent of the line with the
                    # last open bracket
                    self.reindent_to(y.compute_bracket_indent())
                elif c == PyParse.C_BACKSLASH:
                    # if more than one line in this stmt already, just
                    # mimic the current indent; else if initial line
                    # has a start on an assignment stmt, indent to
                    # beyond leftmost =; else to beyond first chunk of
                    # non-whitespace on initial line
                    if y.get_num_lines_in_stmt() > 1:
                        text.insert("insert", indent)
                    else:
                        self.reindent_to(y.compute_backslash_indent())
                else:
                    assert 0, "bogus continuation type %r" % (c,)
                return "break"

            # This line starts a brand new stmt; indent relative to
            # indentation of initial line of closest preceding
            # interesting stmt.
            indent = y.get_base_indent_string()
            text.insert("insert", indent)
            if y.is_block_opener():
                self.smart_indent_event(event)
            elif indent and y.is_block_closer():
                self.smart_backspace_event(event)
            return "break"
        finally:
            text.see("insert")
            text.undo_block_stop()

    # Our editwin provides a is_char_in_string function that works
    # with a Tk text index, but PyParse only knows about offsets into
    # a string. This builds a function for PyParse that accepts an
    # offset.

    def _build_char_in_string_func(self, startindex):
        def inner(offset, _startindex=startindex,
                  _icis=self.is_char_in_string):
            return _icis(_startindex + "+%dc" % offset)
        return inner

    def indent_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, self.tabwidth)
                effective = effective + self.indentwidth
                lines[pos] = self._make_blanks(effective) + line[raw:]
        self.set_region(head, tail, chars, lines)
        return "break"

    def dedent_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, self.tabwidth)
                effective = max(effective - self.indentwidth, 0)
                lines[pos] = self._make_blanks(effective) + line[raw:]
        self.set_region(head, tail, chars, lines)
        return "break"

    def comment_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines) - 1):
            line = lines[pos]
            lines[pos] = '##' + line
        self.set_region(head, tail, chars, lines)

    def uncomment_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if not line:
                continue
            if line[:2] == '##':
                line = line[2:]
            elif line[:1] == '#':
                line = line[1:]
            lines[pos] = line
        self.set_region(head, tail, chars, lines)

    def tabify_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        tabwidth = self._asktabwidth()
        if tabwidth is None: return
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, tabwidth)
                ntabs, nspaces = divmod(effective, tabwidth)
                lines[pos] = '\t' * ntabs + ' ' * nspaces + line[raw:]
        self.set_region(head, tail, chars, lines)

    def untabify_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        tabwidth = self._asktabwidth()
        if tabwidth is None: return
        for pos in range(len(lines)):
            lines[pos] = lines[pos].expandtabs(tabwidth)
        self.set_region(head, tail, chars, lines)

    def toggle_tabs_event(self, event):
        if self.askyesno(
              "Toggle tabs",
              "Turn tabs " + ("on", "off")[self.usetabs] +
              "?\nIndent width " +
              ("will be", "remains at")[self.usetabs] + " 8." +
              "\n Note: a tab is always 8 columns",
              parent=self.text):
            self.usetabs = not self.usetabs
            # Try to prevent inconsistent indentation.
            # User must change indent width manually after using tabs.
            self.indentwidth = 8
        return "break"

    # XXX this isn't bound to anything -- see tabwidth comments
##     def change_tabwidth_event(self, event):
##         new = self._asktabwidth()
##         if new != self.tabwidth:
##             self.tabwidth = new
##             self.set_indentation_params(0, guess=0)
##         return "break"

    def change_indentwidth_event(self, event):
        new = self.askinteger(
                  "Indent width",
                  "New indent width (2-16)\n(Always use 8 when using tabs)",
                  parent=self.text,
                  initialvalue=self.indentwidth,
                  minvalue=2,
                  maxvalue=16)
        if new and new != self.indentwidth and not self.usetabs:
            self.indentwidth = new
        return "break"

    def get_region(self):
        text = self.text
        first, last = self.get_selection_indices()
        if first and last:
            head = text.index(first + " linestart")
            tail = text.index(last + "-1c lineend +1c")
        else:
            head = text.index("insert linestart")
            tail = text.index("insert lineend +1c")
        chars = text.get(head, tail)
        lines = chars.split("\n")
        return head, tail, chars, lines

    def set_region(self, head, tail, chars, lines):
        text = self.text
        newchars = "\n".join(lines)
        if newchars == chars:
            text.bell()
            return
        text.tag_remove("sel", "1.0", "end")
        text.mark_set("insert", head)
        text.undo_block_start()
        text.delete(head, tail)
        text.insert(head, newchars)
        text.undo_block_stop()
        text.tag_add("sel", head, "insert")

    # Make string that displays as n leading blanks.

    def _make_blanks(self, n):
        if self.usetabs:
            ntabs, nspaces = divmod(n, self.tabwidth)
            return '\t' * ntabs + ' ' * nspaces
        else:
            return ' ' * n

    # Delete from beginning of line to insert point, then reinsert
    # column logical (meaning use tabs if appropriate) spaces.

    def reindent_to(self, column):
        text = self.text
        text.undo_block_start()
        if text.compare("insert linestart", "!=", "insert"):
            text.delete("insert linestart", "insert")
        if column:
            text.insert("insert", self._make_blanks(column))
        text.undo_block_stop()

    def _asktabwidth(self):
        return self.askinteger(
            "Tab width",
            "Columns per tab? (2-16)",
            parent=self.text,
            initialvalue=self.indentwidth,
            minvalue=2,
            maxvalue=16)

    # Guess indentwidth from text content.
    # Return guessed indentwidth.  This should not be believed unless
    # it's in a reasonable range (e.g., it will be 0 if no indented
    # blocks are found).

    def guess_indent(self):
        opener, indented = IndentSearcher(self.text, self.tabwidth).run()
        if opener and indented:
            raw, indentsmall = classifyws(opener, self.tabwidth)
            raw, indentlarge = classifyws(indented, self.tabwidth)
        else:
            indentsmall = indentlarge = 0
        return indentlarge - indentsmall

# "line.col" -> line, as an int
def index2line(index):
    return int(float(index))

# Look at the leading whitespace in s.
# Return pair (# of leading ws characters,
#              effective # of leading blanks after expanding
#              tabs to width tabwidth)

def classifyws(s, tabwidth):
    raw = effective = 0
    for ch in s:
        if ch == ' ':
            raw = raw + 1
            effective = effective + 1
        elif ch == '\t':
            raw = raw + 1
            effective = (effective // tabwidth + 1) * tabwidth
        else:
            break
    return raw, effective

import tokenize
_tokenize = tokenize
del tokenize

class IndentSearcher(object):

    # .run() chews over the Text widget, looking for a block opener
    # and the stmt following it.  Returns a pair,
    #     (line containing block opener, line containing stmt)
    # Either or both may be None.

    def __init__(self, text, tabwidth):
        self.text = text
        self.tabwidth = tabwidth
        self.i = self.finished = 0
        self.blkopenline = self.indentedline = None

    def readline(self):
        if self.finished:
            return ""
        i = self.i = self.i + 1
        mark = repr(i) + ".0"
        if self.text.compare(mark, ">=", "end"):
            return ""
        return self.text.get(mark, mark + " lineend+1c")

    def tokeneater(self, type, token, start, end, line,
                   INDENT=_tokenize.INDENT,
                   NAME=_tokenize.NAME,
                   OPENERS=('class', 'def', 'for', 'if', 'try', 'while')):
        if self.finished:
            pass
        elif type == NAME and token in OPENERS:
            self.blkopenline = line
        elif type == INDENT and self.blkopenline:
            self.indentedline = line
            self.finished = 1

    def run(self):
        save_tabsize = _tokenize.tabsize
        _tokenize.tabsize = self.tabwidth
        try:
            try:
                tokens = _tokenize.generate_tokens(self.readline)
                for token in tokens:
                    self.tokeneater(*token)
            except (_tokenize.TokenError, SyntaxError):
                # since we cut off the tokenizer early, we can trigger
                # spurious errors
                pass
        finally:
            _tokenize.tabsize = save_tabsize
        return self.blkopenline, self.indentedline

### end autoindent code ###

def prepstr(s):
    # Helper to extract the underscore from a string, e.g.
    # prepstr("Co_py") returns (2, "Copy").
    i = s.find('_')
    if i >= 0:
        s = s[:i] + s[i+1:]
    return i, s


keynames = {
 'bracketleft': '[',
 'bracketright': ']',
 'slash': '/',
}

def get_accelerator(keydefs, eventname):
    keylist = keydefs.get(eventname)
    # issue10940: temporary workaround to prevent hang with OS X Cocoa Tk 8.5
    # if not keylist:
    if (not keylist) or (macosxSupport.isCocoaTk() and eventname in {
                            "<<open-module>>",
                            "<<goto-line>>",
                            "<<change-indentwidth>>"}):
        return ""
    s = keylist[0]
    s = re.sub(r"-[a-z]\b", lambda m: m.group().upper(), s)
    s = re.sub(r"\b\w+\b", lambda m: keynames.get(m.group(), m.group()), s)
    s = re.sub("Key-", "", s)
    s = re.sub("Cancel","Ctrl-Break",s)   # dscherer@cmu.edu
    s = re.sub("Control-", "Ctrl-", s)
    s = re.sub("-", "+", s)
    s = re.sub("><", " ", s)
    s = re.sub("<", "", s)
    s = re.sub(">", "", s)
    return s


def fixwordbreaks(root):
    # Make sure that Tk's double-click and next/previous word
    # operations use our definition of a word (i.e. an identifier)
    tk = root.tk
    tk.call('tcl_wordBreakAfter', 'a b', 0) # make sure word.tcl is loaded
    tk.call('set', 'tcl_wordchars', '[a-zA-Z0-9_]')
    tk.call('set', 'tcl_nonwordchars', '[^a-zA-Z0-9_]')


def _editor_window(parent):  # htest #
    # error if close master window first - timer event, after script
    root = parent
    fixwordbreaks(root)
    if sys.argv[1:]:
        filename = sys.argv[1]
    else:
        filename = None
    macosxSupport.setupApp(root, None)
    edit = EditorWindow(root=root, filename=filename)
    edit.text.bind("<<close-all-windows>>", edit.close_event)
    # Does not stop error, neither does following
    # edit.text.bind("<<close-window>>", edit.close_event)

if __name__ == '__main__':
    from idlelib.idle_test.htest import run
    run(_editor_window)
20' href='#n820'>820</a>
<a id='n821' href='#n821'>821</a>
<a id='n822' href='#n822'>822</a>
<a id='n823' href='#n823'>823</a>
<a id='n824' href='#n824'>824</a>
<a id='n825' href='#n825'>825</a>
<a id='n826' href='#n826'>826</a>
<a id='n827' href='#n827'>827</a>
<a id='n828' href='#n828'>828</a>
<a id='n829' href='#n829'>829</a>
<a id='n830' href='#n830'>830</a>
<a id='n831' href='#n831'>831</a>
<a id='n832' href='#n832'>832</a>
<a id='n833' href='#n833'>833</a>
<a id='n834' href='#n834'>834</a>
<a id='n835' href='#n835'>835</a>
<a id='n836' href='#n836'>836</a>
<a id='n837' href='#n837'>837</a>
<a id='n838' href='#n838'>838</a>
<a id='n839' href='#n839'>839</a>
<a id='n840' href='#n840'>840</a>
<a id='n841' href='#n841'>841</a>
<a id='n842' href='#n842'>842</a>
<a id='n843' href='#n843'>843</a>
<a id='n844' href='#n844'>844</a>
<a id='n845' href='#n845'>845</a>
<a id='n846' href='#n846'>846</a>
<a id='n847' href='#n847'>847</a>
<a id='n848' href='#n848'>848</a>
<a id='n849' href='#n849'>849</a>
<a id='n850' href='#n850'>850</a>
<a id='n851' href='#n851'>851</a>
<a id='n852' href='#n852'>852</a>
<a id='n853' href='#n853'>853</a>
<a id='n854' href='#n854'>854</a>
<a id='n855' href='#n855'>855</a>
<a id='n856' href='#n856'>856</a>
<a id='n857' href='#n857'>857</a>
<a id='n858' href='#n858'>858</a>
<a id='n859' href='#n859'>859</a>
<a id='n860' href='#n860'>860</a>
<a id='n861' href='#n861'>861</a>
<a id='n862' href='#n862'>862</a>
<a id='n863' href='#n863'>863</a>
<a id='n864' href='#n864'>864</a>
<a id='n865' href='#n865'>865</a>
<a id='n866' href='#n866'>866</a>
<a id='n867' href='#n867'>867</a>
<a id='n868' href='#n868'>868</a>
<a id='n869' href='#n869'>869</a>
<a id='n870' href='#n870'>870</a>
<a id='n871' href='#n871'>871</a>
<a id='n872' href='#n872'>872</a>
<a id='n873' href='#n873'>873</a>
<a id='n874' href='#n874'>874</a>
<a id='n875' href='#n875'>875</a>
<a id='n876' href='#n876'>876</a>
<a id='n877' href='#n877'>877</a>
<a id='n878' href='#n878'>878</a>
<a id='n879' href='#n879'>879</a>
<a id='n880' href='#n880'>880</a>
<a id='n881' href='#n881'>881</a>
<a id='n882' href='#n882'>882</a>
<a id='n883' href='#n883'>883</a>
<a id='n884' href='#n884'>884</a>
<a id='n885' href='#n885'>885</a>
<a id='n886' href='#n886'>886</a>
<a id='n887' href='#n887'>887</a>
<a id='n888' href='#n888'>888</a>
<a id='n889' href='#n889'>889</a>
<a id='n890' href='#n890'>890</a>
<a id='n891' href='#n891'>891</a>
<a id='n892' href='#n892'>892</a>
<a id='n893' href='#n893'>893</a>
<a id='n894' href='#n894'>894</a>
<a id='n895' href='#n895'>895</a>
<a id='n896' href='#n896'>896</a>
<a id='n897' href='#n897'>897</a>
<a id='n898' href='#n898'>898</a>
<a id='n899' href='#n899'>899</a>
<a id='n900' href='#n900'>900</a>
<a id='n901' href='#n901'>901</a>
<a id='n902' href='#n902'>902</a>
<a id='n903' href='#n903'>903</a>
<a id='n904' href='#n904'>904</a>
<a id='n905' href='#n905'>905</a>
<a id='n906' href='#n906'>906</a>
<a id='n907' href='#n907'>907</a>
<a id='n908' href='#n908'>908</a>
<a id='n909' href='#n909'>909</a>
<a id='n910' href='#n910'>910</a>
<a id='n911' href='#n911'>911</a>
<a id='n912' href='#n912'>912</a>
<a id='n913' href='#n913'>913</a>
<a id='n914' href='#n914'>914</a>
<a id='n915' href='#n915'>915</a>
<a id='n916' href='#n916'>916</a>
<a id='n917' href='#n917'>917</a>
<a id='n918' href='#n918'>918</a>
<a id='n919' href='#n919'>919</a>
<a id='n920' href='#n920'>920</a>
<a id='n921' href='#n921'>921</a>
<a id='n922' href='#n922'>922</a>
<a id='n923' href='#n923'>923</a>
<a id='n924' href='#n924'>924</a>
<a id='n925' href='#n925'>925</a>
<a id='n926' href='#n926'>926</a>
<a id='n927' href='#n927'>927</a>
<a id='n928' href='#n928'>928</a>
<a id='n929' href='#n929'>929</a>
<a id='n930' href='#n930'>930</a>
<a id='n931' href='#n931'>931</a>
<a id='n932' href='#n932'>932</a>
<a id='n933' href='#n933'>933</a>
<a id='n934' href='#n934'>934</a>
<a id='n935' href='#n935'>935</a>
<a id='n936' href='#n936'>936</a>
<a id='n937' href='#n937'>937</a>
<a id='n938' href='#n938'>938</a>
<a id='n939' href='#n939'>939</a>
<a id='n940' href='#n940'>940</a>
<a id='n941' href='#n941'>941</a>
<a id='n942' href='#n942'>942</a>
<a id='n943' href='#n943'>943</a>
<a id='n944' href='#n944'>944</a>
<a id='n945' href='#n945'>945</a>
<a id='n946' href='#n946'>946</a>
<a id='n947' href='#n947'>947</a>
<a id='n948' href='#n948'>948</a>
<a id='n949' href='#n949'>949</a>
<a id='n950' href='#n950'>950</a>
<a id='n951' href='#n951'>951</a>
<a id='n952' href='#n952'>952</a>
<a id='n953' href='#n953'>953</a>
<a id='n954' href='#n954'>954</a>
<a id='n955' href='#n955'>955</a>
<a id='n956' href='#n956'>956</a>
<a id='n957' href='#n957'>957</a>
<a id='n958' href='#n958'>958</a>
<a id='n959' href='#n959'>959</a>
<a id='n960' href='#n960'>960</a>
<a id='n961' href='#n961'>961</a>
<a id='n962' href='#n962'>962</a>
<a id='n963' href='#n963'>963</a>
<a id='n964' href='#n964'>964</a>
<a id='n965' href='#n965'>965</a>
<a id='n966' href='#n966'>966</a>
<a id='n967' href='#n967'>967</a>
<a id='n968' href='#n968'>968</a>
<a id='n969' href='#n969'>969</a>
<a id='n970' href='#n970'>970</a>
<a id='n971' href='#n971'>971</a>
<a id='n972' href='#n972'>972</a>
<a id='n973' href='#n973'>973</a>
<a id='n974' href='#n974'>974</a>
<a id='n975' href='#n975'>975</a>
<a id='n976' href='#n976'>976</a>
<a id='n977' href='#n977'>977</a>
<a id='n978' href='#n978'>978</a>
<a id='n979' href='#n979'>979</a>
<a id='n980' href='#n980'>980</a>
<a id='n981' href='#n981'>981</a>
<a id='n982' href='#n982'>982</a>
<a id='n983' href='#n983'>983</a>
<a id='n984' href='#n984'>984</a>
<a id='n985' href='#n985'>985</a>
<a id='n986' href='#n986'>986</a>
<a id='n987' href='#n987'>987</a>
<a id='n988' href='#n988'>988</a>
<a id='n989' href='#n989'>989</a>
<a id='n990' href='#n990'>990</a>
<a id='n991' href='#n991'>991</a>
<a id='n992' href='#n992'>992</a>
<a id='n993' href='#n993'>993</a>
<a id='n994' href='#n994'>994</a>
<a id='n995' href='#n995'>995</a>
<a id='n996' href='#n996'>996</a>
<a id='n997' href='#n997'>997</a>
<a id='n998' href='#n998'>998</a>
<a id='n999' href='#n999'>999</a>
<a id='n1000' href='#n1000'>1000</a>
<a id='n1001' href='#n1001'>1001</a>
<a id='n1002' href='#n1002'>1002</a>
<a id='n1003' href='#n1003'>1003</a>
<a id='n1004' href='#n1004'>1004</a>
<a id='n1005' href='#n1005'>1005</a>
<a id='n1006' href='#n1006'>1006</a>
<a id='n1007' href='#n1007'>1007</a>
<a id='n1008' href='#n1008'>1008</a>
<a id='n1009' href='#n1009'>1009</a>
<a id='n1010' href='#n1010'>1010</a>
<a id='n1011' href='#n1011'>1011</a>
<a id='n1012' href='#n1012'>1012</a>
<a id='n1013' href='#n1013'>1013</a>
<a id='n1014' href='#n1014'>1014</a>
<a id='n1015' href='#n1015'>1015</a>
<a id='n1016' href='#n1016'>1016</a>
<a id='n1017' href='#n1017'>1017</a>
<a id='n1018' href='#n1018'>1018</a>
<a id='n1019' href='#n1019'>1019</a>
<a id='n1020' href='#n1020'>1020</a>
<a id='n1021' href='#n1021'>1021</a>
<a id='n1022' href='#n1022'>1022</a>
<a id='n1023' href='#n1023'>1023</a>
<a id='n1024' href='#n1024'>1024</a>
<a id='n1025' href='#n1025'>1025</a>
<a id='n1026' href='#n1026'>1026</a>
<a id='n1027' href='#n1027'>1027</a>
<a id='n1028' href='#n1028'>1028</a>
<a id='n1029' href='#n1029'>1029</a>
<a id='n1030' href='#n1030'>1030</a>
<a id='n1031' href='#n1031'>1031</a>
<a id='n1032' href='#n1032'>1032</a>
<a id='n1033' href='#n1033'>1033</a>
<a id='n1034' href='#n1034'>1034</a>
<a id='n1035' href='#n1035'>1035</a>
<a id='n1036' href='#n1036'>1036</a>
<a id='n1037' href='#n1037'>1037</a>
<a id='n1038' href='#n1038'>1038</a>
<a id='n1039' href='#n1039'>1039</a>
<a id='n1040' href='#n1040'>1040</a>
<a id='n1041' href='#n1041'>1041</a>
<a id='n1042' href='#n1042'>1042</a>
<a id='n1043' href='#n1043'>1043</a>
<a id='n1044' href='#n1044'>1044</a>
<a id='n1045' href='#n1045'>1045</a>
<a id='n1046' href='#n1046'>1046</a>
<a id='n1047' href='#n1047'>1047</a>
<a id='n1048' href='#n1048'>1048</a>
<a id='n1049' href='#n1049'>1049</a>
<a id='n1050' href='#n1050'>1050</a>
<a id='n1051' href='#n1051'>1051</a>
<a id='n1052' href='#n1052'>1052</a>
<a id='n1053' href='#n1053'>1053</a>
<a id='n1054' href='#n1054'>1054</a>
<a id='n1055' href='#n1055'>1055</a>
<a id='n1056' href='#n1056'>1056</a>
<a id='n1057' href='#n1057'>1057</a>
<a id='n1058' href='#n1058'>1058</a>
<a id='n1059' href='#n1059'>1059</a>
<a id='n1060' href='#n1060'>1060</a>
<a id='n1061' href='#n1061'>1061</a>
<a id='n1062' href='#n1062'>1062</a>
<a id='n1063' href='#n1063'>1063</a>
<a id='n1064' href='#n1064'>1064</a>
<a id='n1065' href='#n1065'>1065</a>
<a id='n1066' href='#n1066'>1066</a>
<a id='n1067' href='#n1067'>1067</a>
<a id='n1068' href='#n1068'>1068</a>
<a id='n1069' href='#n1069'>1069</a>
<a id='n1070' href='#n1070'>1070</a>
<a id='n1071' href='#n1071'>1071</a>
<a id='n1072' href='#n1072'>1072</a>
<a id='n1073' href='#n1073'>1073</a>
<a id='n1074' href='#n1074'>1074</a>
<a id='n1075' href='#n1075'>1075</a>
<a id='n1076' href='#n1076'>1076</a>
<a id='n1077' href='#n1077'>1077</a>
<a id='n1078' href='#n1078'>1078</a>
<a id='n1079' href='#n1079'>1079</a>
<a id='n1080' href='#n1080'>1080</a>
<a id='n1081' href='#n1081'>1081</a>
<a id='n1082' href='#n1082'>1082</a>
<a id='n1083' href='#n1083'>1083</a>
<a id='n1084' href='#n1084'>1084</a>
<a id='n1085' href='#n1085'>1085</a>
<a id='n1086' href='#n1086'>1086</a>
<a id='n1087' href='#n1087'>1087</a>
<a id='n1088' href='#n1088'>1088</a>
<a id='n1089' href='#n1089'>1089</a>
<a id='n1090' href='#n1090'>1090</a>
<a id='n1091' href='#n1091'>1091</a>
<a id='n1092' href='#n1092'>1092</a>
<a id='n1093' href='#n1093'>1093</a>
<a id='n1094' href='#n1094'>1094</a>
<a id='n1095' href='#n1095'>1095</a>
<a id='n1096' href='#n1096'>1096</a>
<a id='n1097' href='#n1097'>1097</a>
<a id='n1098' href='#n1098'>1098</a>
<a id='n1099' href='#n1099'>1099</a>
<a id='n1100' href='#n1100'>1100</a>
<a id='n1101' href='#n1101'>1101</a>
<a id='n1102' href='#n1102'>1102</a>
<a id='n1103' href='#n1103'>1103</a>
<a id='n1104' href='#n1104'>1104</a>
<a id='n1105' href='#n1105'>1105</a>
<a id='n1106' href='#n1106'>1106</a>
<a id='n1107' href='#n1107'>1107</a>
<a id='n1108' href='#n1108'>1108</a>
<a id='n1109' href='#n1109'>1109</a>
<a id='n1110' href='#n1110'>1110</a>
<a id='n1111' href='#n1111'>1111</a>
<a id='n1112' href='#n1112'>1112</a>
<a id='n1113' href='#n1113'>1113</a>
<a id='n1114' href='#n1114'>1114</a>
<a id='n1115' href='#n1115'>1115</a>
<a id='n1116' href='#n1116'>1116</a>
<a id='n1117' href='#n1117'>1117</a>
<a id='n1118' href='#n1118'>1118</a>
<a id='n1119' href='#n1119'>1119</a>
<a id='n1120' href='#n1120'>1120</a>
<a id='n1121' href='#n1121'>1121</a>
<a id='n1122' href='#n1122'>1122</a>
<a id='n1123' href='#n1123'>1123</a>
<a id='n1124' href='#n1124'>1124</a>
<a id='n1125' href='#n1125'>1125</a>
<a id='n1126' href='#n1126'>1126</a>
<a id='n1127' href='#n1127'>1127</a>
<a id='n1128' href='#n1128'>1128</a>
<a id='n1129' href='#n1129'>1129</a>
<a id='n1130' href='#n1130'>1130</a>
<a id='n1131' href='#n1131'>1131</a>
<a id='n1132' href='#n1132'>1132</a>
<a id='n1133' href='#n1133'>1133</a>
<a id='n1134' href='#n1134'>1134</a>
<a id='n1135' href='#n1135'>1135</a>
<a id='n1136' href='#n1136'>1136</a>
<a id='n1137' href='#n1137'>1137</a>
<a id='n1138' href='#n1138'>1138</a>
<a id='n1139' href='#n1139'>1139</a>
<a id='n1140' href='#n1140'>1140</a>
<a id='n1141' href='#n1141'>1141</a>
<a id='n1142' href='#n1142'>1142</a>
<a id='n1143' href='#n1143'>1143</a>
<a id='n1144' href='#n1144'>1144</a>
<a id='n1145' href='#n1145'>1145</a>
<a id='n1146' href='#n1146'>1146</a>
<a id='n1147' href='#n1147'>1147</a>
<a id='n1148' href='#n1148'>1148</a>
<a id='n1149' href='#n1149'>1149</a>
<a id='n1150' href='#n1150'>1150</a>
<a id='n1151' href='#n1151'>1151</a>
<a id='n1152' href='#n1152'>1152</a>
<a id='n1153' href='#n1153'>1153</a>
<a id='n1154' href='#n1154'>1154</a>
<a id='n1155' href='#n1155'>1155</a>
<a id='n1156' href='#n1156'>1156</a>
<a id='n1157' href='#n1157'>1157</a>
<a id='n1158' href='#n1158'>1158</a>
<a id='n1159' href='#n1159'>1159</a>
<a id='n1160' href='#n1160'>1160</a>
<a id='n1161' href='#n1161'>1161</a>
<a id='n1162' href='#n1162'>1162</a>
<a id='n1163' href='#n1163'>1163</a>
<a id='n1164' href='#n1164'>1164</a>
<a id='n1165' href='#n1165'>1165</a>
<a id='n1166' href='#n1166'>1166</a>
<a id='n1167' href='#n1167'>1167</a>
<a id='n1168' href='#n1168'>1168</a>
<a id='n1169' href='#n1169'>1169</a>
<a id='n1170' href='#n1170'>1170</a>
<a id='n1171' href='#n1171'>1171</a>
<a id='n1172' href='#n1172'>1172</a>
<a id='n1173' href='#n1173'>1173</a>
<a id='n1174' href='#n1174'>1174</a>
<a id='n1175' href='#n1175'>1175</a>
<a id='n1176' href='#n1176'>1176</a>
<a id='n1177' href='#n1177'>1177</a>
<a id='n1178' href='#n1178'>1178</a>
<a id='n1179' href='#n1179'>1179</a>
<a id='n1180' href='#n1180'>1180</a>
<a id='n1181' href='#n1181'>1181</a>
<a id='n1182' href='#n1182'>1182</a>
<a id='n1183' href='#n1183'>1183</a>
<a id='n1184' href='#n1184'>1184</a>
<a id='n1185' href='#n1185'>1185</a>
<a id='n1186' href='#n1186'>1186</a>
<a id='n1187' href='#n1187'>1187</a>
<a id='n1188' href='#n1188'>1188</a>
<a id='n1189' href='#n1189'>1189</a>
<a id='n1190' href='#n1190'>1190</a>
<a id='n1191' href='#n1191'>1191</a>
<a id='n1192' href='#n1192'>1192</a>
<a id='n1193' href='#n1193'>1193</a>
<a id='n1194' href='#n1194'>1194</a>
<a id='n1195' href='#n1195'>1195</a>
<a id='n1196' href='#n1196'>1196</a>
<a id='n1197' href='#n1197'>1197</a>
<a id='n1198' href='#n1198'>1198</a>
<a id='n1199' href='#n1199'>1199</a>
<a id='n1200' href='#n1200'>1200</a>
<a id='n1201' href='#n1201'>1201</a>
<a id='n1202' href='#n1202'>1202</a>
<a id='n1203' href='#n1203'>1203</a>
<a id='n1204' href='#n1204'>1204</a>
<a id='n1205' href='#n1205'>1205</a>
<a id='n1206' href='#n1206'>1206</a>
<a id='n1207' href='#n1207'>1207</a>
<a id='n1208' href='#n1208'>1208</a>
<a id='n1209' href='#n1209'>1209</a>
<a id='n1210' href='#n1210'>1210</a>
<a id='n1211' href='#n1211'>1211</a>
<a id='n1212' href='#n1212'>1212</a>
<a id='n1213' href='#n1213'>1213</a>
<a id='n1214' href='#n1214'>1214</a>
<a id='n1215' href='#n1215'>1215</a>
<a id='n1216' href='#n1216'>1216</a>
<a id='n1217' href='#n1217'>1217</a>
<a id='n1218' href='#n1218'>1218</a>
<a id='n1219' href='#n1219'>1219</a>
<a id='n1220' href='#n1220'>1220</a>
<a id='n1221' href='#n1221'>1221</a>
<a id='n1222' href='#n1222'>1222</a>
<a id='n1223' href='#n1223'>1223</a>
<a id='n1224' href='#n1224'>1224</a>
<a id='n1225' href='#n1225'>1225</a>
<a id='n1226' href='#n1226'>1226</a>
<a id='n1227' href='#n1227'>1227</a>
<a id='n1228' href='#n1228'>1228</a>
<a id='n1229' href='#n1229'>1229</a>
<a id='n1230' href='#n1230'>1230</a>
<a id='n1231' href='#n1231'>1231</a>
<a id='n1232' href='#n1232'>1232</a>
<a id='n1233' href='#n1233'>1233</a>
<a id='n1234' href='#n1234'>1234</a>
<a id='n1235' href='#n1235'>1235</a>
<a id='n1236' href='#n1236'>1236</a>
<a id='n1237' href='#n1237'>1237</a>
<a id='n1238' href='#n1238'>1238</a>
<a id='n1239' href='#n1239'>1239</a>
<a id='n1240' href='#n1240'>1240</a>
<a id='n1241' href='#n1241'>1241</a>
<a id='n1242' href='#n1242'>1242</a>
<a id='n1243' href='#n1243'>1243</a>
<a id='n1244' href='#n1244'>1244</a>
<a id='n1245' href='#n1245'>1245</a>
<a id='n1246' href='#n1246'>1246</a>
<a id='n1247' href='#n1247'>1247</a>
<a id='n1248' href='#n1248'>1248</a>
<a id='n1249' href='#n1249'>1249</a>
<a id='n1250' href='#n1250'>1250</a>
<a id='n1251' href='#n1251'>1251</a>
<a id='n1252' href='#n1252'>1252</a>
<a id='n1253' href='#n1253'>1253</a>
<a id='n1254' href='#n1254'>1254</a>
<a id='n1255' href='#n1255'>1255</a>
<a id='n1256' href='#n1256'>1256</a>
<a id='n1257' href='#n1257'>1257</a>
<a id='n1258' href='#n1258'>1258</a>
<a id='n1259' href='#n1259'>1259</a>
<a id='n1260' href='#n1260'>1260</a>
<a id='n1261' href='#n1261'>1261</a>
<a id='n1262' href='#n1262'>1262</a>
<a id='n1263' href='#n1263'>1263</a>
<a id='n1264' href='#n1264'>1264</a>
<a id='n1265' href='#n1265'>1265</a>
<a id='n1266' href='#n1266'>1266</a>
<a id='n1267' href='#n1267'>1267</a>
<a id='n1268' href='#n1268'>1268</a>
<a id='n1269' href='#n1269'>1269</a>
<a id='n1270' href='#n1270'>1270</a>
<a id='n1271' href='#n1271'>1271</a>
<a id='n1272' href='#n1272'>1272</a>
<a id='n1273' href='#n1273'>1273</a>
<a id='n1274' href='#n1274'>1274</a>
<a id='n1275' href='#n1275'>1275</a>
<a id='n1276' href='#n1276'>1276</a>
<a id='n1277' href='#n1277'>1277</a>
<a id='n1278' href='#n1278'>1278</a>
<a id='n1279' href='#n1279'>1279</a>
<a id='n1280' href='#n1280'>1280</a>
<a id='n1281' href='#n1281'>1281</a>
<a id='n1282' href='#n1282'>1282</a>
<a id='n1283' href='#n1283'>1283</a>
<a id='n1284' href='#n1284'>1284</a>
<a id='n1285' href='#n1285'>1285</a>
<a id='n1286' href='#n1286'>1286</a>
<a id='n1287' href='#n1287'>1287</a>
<a id='n1288' href='#n1288'>1288</a>
<a id='n1289' href='#n1289'>1289</a>
<a id='n1290' href='#n1290'>1290</a>
<a id='n1291' href='#n1291'>1291</a>
<a id='n1292' href='#n1292'>1292</a>
<a id='n1293' href='#n1293'>1293</a>
<a id='n1294' href='#n1294'>1294</a>
<a id='n1295' href='#n1295'>1295</a>
<a id='n1296' href='#n1296'>1296</a>
<a id='n1297' href='#n1297'>1297</a>
<a id='n1298' href='#n1298'>1298</a>
<a id='n1299' href='#n1299'>1299</a>
<a id='n1300' href='#n1300'>1300</a>
<a id='n1301' href='#n1301'>1301</a>
<a id='n1302' href='#n1302'>1302</a>
<a id='n1303' href='#n1303'>1303</a>
<a id='n1304' href='#n1304'>1304</a>
<a id='n1305' href='#n1305'>1305</a>
<a id='n1306' href='#n1306'>1306</a>
<a id='n1307' href='#n1307'>1307</a>
<a id='n1308' href='#n1308'>1308</a>
<a id='n1309' href='#n1309'>1309</a>
<a id='n1310' href='#n1310'>1310</a>
<a id='n1311' href='#n1311'>1311</a>
<a id='n1312' href='#n1312'>1312</a>
<a id='n1313' href='#n1313'>1313</a>
<a id='n1314' href='#n1314'>1314</a>
<a id='n1315' href='#n1315'>1315</a>
<a id='n1316' href='#n1316'>1316</a>
<a id='n1317' href='#n1317'>1317</a>
<a id='n1318' href='#n1318'>1318</a>
<a id='n1319' href='#n1319'>1319</a>
<a id='n1320' href='#n1320'>1320</a>
<a id='n1321' href='#n1321'>1321</a>
<a id='n1322' href='#n1322'>1322</a>
<a id='n1323' href='#n1323'>1323</a>
<a id='n1324' href='#n1324'>1324</a>
<a id='n1325' href='#n1325'>1325</a>
<a id='n1326' href='#n1326'>1326</a>
<a id='n1327' href='#n1327'>1327</a>
<a id='n1328' href='#n1328'>1328</a>
<a id='n1329' href='#n1329'>1329</a>
<a id='n1330' href='#n1330'>1330</a>
<a id='n1331' href='#n1331'>1331</a>
<a id='n1332' href='#n1332'>1332</a>
<a id='n1333' href='#n1333'>1333</a>
<a id='n1334' href='#n1334'>1334</a>
<a id='n1335' href='#n1335'>1335</a>
<a id='n1336' href='#n1336'>1336</a>
<a id='n1337' href='#n1337'>1337</a>
<a id='n1338' href='#n1338'>1338</a>
<a id='n1339' href='#n1339'>1339</a>
<a id='n1340' href='#n1340'>1340</a>
<a id='n1341' href='#n1341'>1341</a>
<a id='n1342' href='#n1342'>1342</a>
<a id='n1343' href='#n1343'>1343</a>
<a id='n1344' href='#n1344'>1344</a>
<a id='n1345' href='#n1345'>1345</a>
<a id='n1346' href='#n1346'>1346</a>
<a id='n1347' href='#n1347'>1347</a>
<a id='n1348' href='#n1348'>1348</a>
<a id='n1349' href='#n1349'>1349</a>
<a id='n1350' href='#n1350'>1350</a>
<a id='n1351' href='#n1351'>1351</a>
<a id='n1352' href='#n1352'>1352</a>
<a id='n1353' href='#n1353'>1353</a>
<a id='n1354' href='#n1354'>1354</a>
<a id='n1355' href='#n1355'>1355</a>
<a id='n1356' href='#n1356'>1356</a>
<a id='n1357' href='#n1357'>1357</a>
<a id='n1358' href='#n1358'>1358</a>
<a id='n1359' href='#n1359'>1359</a>
<a id='n1360' href='#n1360'>1360</a>
<a id='n1361' href='#n1361'>1361</a>
<a id='n1362' href='#n1362'>1362</a>
<a id='n1363' href='#n1363'>1363</a>
<a id='n1364' href='#n1364'>1364</a>
<a id='n1365' href='#n1365'>1365</a>
<a id='n1366' href='#n1366'>1366</a>
<a id='n1367' href='#n1367'>1367</a>
<a id='n1368' href='#n1368'>1368</a>
<a id='n1369' href='#n1369'>1369</a>
<a id='n1370' href='#n1370'>1370</a>
<a id='n1371' href='#n1371'>1371</a>
<a id='n1372' href='#n1372'>1372</a>
<a id='n1373' href='#n1373'>1373</a>
<a id='n1374' href='#n1374'>1374</a>
<a id='n1375' href='#n1375'>1375</a>
<a id='n1376' href='#n1376'>1376</a>
<a id='n1377' href='#n1377'>1377</a>
<a id='n1378' href='#n1378'>1378</a>
<a id='n1379' href='#n1379'>1379</a>
<a id='n1380' href='#n1380'>1380</a>
<a id='n1381' href='#n1381'>1381</a>
<a id='n1382' href='#n1382'>1382</a>
<a id='n1383' href='#n1383'>1383</a>
<a id='n1384' href='#n1384'>1384</a>
<a id='n1385' href='#n1385'>1385</a>
<a id='n1386' href='#n1386'>1386</a>
<a id='n1387' href='#n1387'>1387</a>
<a id='n1388' href='#n1388'>1388</a>
<a id='n1389' href='#n1389'>1389</a>
<a id='n1390' href='#n1390'>1390</a>
<a id='n1391' href='#n1391'>1391</a>
<a id='n1392' href='#n1392'>1392</a>
<a id='n1393' href='#n1393'>1393</a>
<a id='n1394' href='#n1394'>1394</a>
<a id='n1395' href='#n1395'>1395</a>
<a id='n1396' href='#n1396'>1396</a>
<a id='n1397' href='#n1397'>1397</a>
<a id='n1398' href='#n1398'>1398</a>
<a id='n1399' href='#n1399'>1399</a>
<a id='n1400' href='#n1400'>1400</a>
<a id='n1401' href='#n1401'>1401</a>
<a id='n1402' href='#n1402'>1402</a>
<a id='n1403' href='#n1403'>1403</a>
<a id='n1404' href='#n1404'>1404</a>
<a id='n1405' href='#n1405'>1405</a>
<a id='n1406' href='#n1406'>1406</a>
<a id='n1407' href='#n1407'>1407</a>
<a id='n1408' href='#n1408'>1408</a>
<a id='n1409' href='#n1409'>1409</a>
<a id='n1410' href='#n1410'>1410</a>
<a id='n1411' href='#n1411'>1411</a>
<a id='n1412' href='#n1412'>1412</a>
<a id='n1413' href='#n1413'>1413</a>
<a id='n1414' href='#n1414'>1414</a>
<a id='n1415' href='#n1415'>1415</a>
<a id='n1416' href='#n1416'>1416</a>
<a id='n1417' href='#n1417'>1417</a>
<a id='n1418' href='#n1418'>1418</a>
<a id='n1419' href='#n1419'>1419</a>
<a id='n1420' href='#n1420'>1420</a>
<a id='n1421' href='#n1421'>1421</a>
<a id='n1422' href='#n1422'>1422</a>
<a id='n1423' href='#n1423'>1423</a>
<a id='n1424' href='#n1424'>1424</a>
<a id='n1425' href='#n1425'>1425</a>
<a id='n1426' href='#n1426'>1426</a>
<a id='n1427' href='#n1427'>1427</a>
<a id='n1428' href='#n1428'>1428</a>
<a id='n1429' href='#n1429'>1429</a>
<a id='n1430' href='#n1430'>1430</a>
<a id='n1431' href='#n1431'>1431</a>
<a id='n1432' href='#n1432'>1432</a>
<a id='n1433' href='#n1433'>1433</a>
<a id='n1434' href='#n1434'>1434</a>
<a id='n1435' href='#n1435'>1435</a>
<a id='n1436' href='#n1436'>1436</a>
<a id='n1437' href='#n1437'>1437</a>
<a id='n1438' href='#n1438'>1438</a>
<a id='n1439' href='#n1439'>1439</a>
<a id='n1440' href='#n1440'>1440</a>
<a id='n1441' href='#n1441'>1441</a>
<a id='n1442' href='#n1442'>1442</a>
<a id='n1443' href='#n1443'>1443</a>
<a id='n1444' href='#n1444'>1444</a>
<a id='n1445' href='#n1445'>1445</a>
<a id='n1446' href='#n1446'>1446</a>
<a id='n1447' href='#n1447'>1447</a>
<a id='n1448' href='#n1448'>1448</a>
<a id='n1449' href='#n1449'>1449</a>
<a id='n1450' href='#n1450'>1450</a>
<a id='n1451' href='#n1451'>1451</a>
<a id='n1452' href='#n1452'>1452</a>
<a id='n1453' href='#n1453'>1453</a>
<a id='n1454' href='#n1454'>1454</a>
<a id='n1455' href='#n1455'>1455</a>
<a id='n1456' href='#n1456'>1456</a>
<a id='n1457' href='#n1457'>1457</a>
<a id='n1458' href='#n1458'>1458</a>
<a id='n1459' href='#n1459'>1459</a>
<a id='n1460' href='#n1460'>1460</a>
<a id='n1461' href='#n1461'>1461</a>
<a id='n1462' href='#n1462'>1462</a>
<a id='n1463' href='#n1463'>1463</a>
<a id='n1464' href='#n1464'>1464</a>
<a id='n1465' href='#n1465'>1465</a>
<a id='n1466' href='#n1466'>1466</a>
<a id='n1467' href='#n1467'>1467</a>
<a id='n1468' href='#n1468'>1468</a>
<a id='n1469' href='#n1469'>1469</a>
<a id='n1470' href='#n1470'>1470</a>
<a id='n1471' href='#n1471'>1471</a>
<a id='n1472' href='#n1472'>1472</a>
<a id='n1473' href='#n1473'>1473</a>
<a id='n1474' href='#n1474'>1474</a>
<a id='n1475' href='#n1475'>1475</a>
<a id='n1476' href='#n1476'>1476</a>
<a id='n1477' href='#n1477'>1477</a>
<a id='n1478' href='#n1478'>1478</a>
<a id='n1479' href='#n1479'>1479</a>
<a id='n1480' href='#n1480'>1480</a>
<a id='n1481' href='#n1481'>1481</a>
<a id='n1482' href='#n1482'>1482</a>
<a id='n1483' href='#n1483'>1483</a>
<a id='n1484' href='#n1484'>1484</a>
<a id='n1485' href='#n1485'>1485</a>
<a id='n1486' href='#n1486'>1486</a>
<a id='n1487' href='#n1487'>1487</a>
<a id='n1488' href='#n1488'>1488</a>
<a id='n1489' href='#n1489'>1489</a>
<a id='n1490' href='#n1490'>1490</a>
<a id='n1491' href='#n1491'>1491</a>
<a id='n1492' href='#n1492'>1492</a>
<a id='n1493' href='#n1493'>1493</a>
<a id='n1494' href='#n1494'>1494</a>
<a id='n1495' href='#n1495'>1495</a>
<a id='n1496' href='#n1496'>1496</a>
<a id='n1497' href='#n1497'>1497</a>
<a id='n1498' href='#n1498'>1498</a>
<a id='n1499' href='#n1499'>1499</a>
<a id='n1500' href='#n1500'>1500</a>
<a id='n1501' href='#n1501'>1501</a>
<a id='n1502' href='#n1502'>1502</a>
<a id='n1503' href='#n1503'>1503</a>
<a id='n1504' href='#n1504'>1504</a>
<a id='n1505' href='#n1505'>1505</a>
<a id='n1506' href='#n1506'>1506</a>
<a id='n1507' href='#n1507'>1507</a>
<a id='n1508' href='#n1508'>1508</a>
<a id='n1509' href='#n1509'>1509</a>
<a id='n1510' href='#n1510'>1510</a>
<a id='n1511' href='#n1511'>1511</a>
<a id='n1512' href='#n1512'>1512</a>
<a id='n1513' href='#n1513'>1513</a>
<a id='n1514' href='#n1514'>1514</a>
<a id='n1515' href='#n1515'>1515</a>
<a id='n1516' href='#n1516'>1516</a>
<a id='n1517' href='#n1517'>1517</a>
<a id='n1518' href='#n1518'>1518</a>
<a id='n1519' href='#n1519'>1519</a>
<a id='n1520' href='#n1520'>1520</a>
<a id='n1521' href='#n1521'>1521</a>
<a id='n1522' href='#n1522'>1522</a>
<a id='n1523' href='#n1523'>1523</a>
<a id='n1524' href='#n1524'>1524</a>
<a id='n1525' href='#n1525'>1525</a>
<a id='n1526' href='#n1526'>1526</a>
<a id='n1527' href='#n1527'>1527</a>
<a id='n1528' href='#n1528'>1528</a>
<a id='n1529' href='#n1529'>1529</a>
<a id='n1530' href='#n1530'>1530</a>
<a id='n1531' href='#n1531'>1531</a>
<a id='n1532' href='#n1532'>1532</a>
<a id='n1533' href='#n1533'>1533</a>
<a id='n1534' href='#n1534'>1534</a>
<a id='n1535' href='#n1535'>1535</a>
<a id='n1536' href='#n1536'>1536</a>
<a id='n1537' href='#n1537'>1537</a>
<a id='n1538' href='#n1538'>1538</a>
<a id='n1539' href='#n1539'>1539</a>
<a id='n1540' href='#n1540'>1540</a>
<a id='n1541' href='#n1541'>1541</a>
<a id='n1542' href='#n1542'>1542</a>
<a id='n1543' href='#n1543'>1543</a>
<a id='n1544' href='#n1544'>1544</a>
<a id='n1545' href='#n1545'>1545</a>
<a id='n1546' href='#n1546'>1546</a>
<a id='n1547' href='#n1547'>1547</a>
<a id='n1548' href='#n1548'>1548</a>
<a id='n1549' href='#n1549'>1549</a>
<a id='n1550' href='#n1550'>1550</a>
<a id='n1551' href='#n1551'>1551</a>
<a id='n1552' href='#n1552'>1552</a>
<a id='n1553' href='#n1553'>1553</a>
<a id='n1554' href='#n1554'>1554</a>
<a id='n1555' href='#n1555'>1555</a>
<a id='n1556' href='#n1556'>1556</a>
<a id='n1557' href='#n1557'>1557</a>
<a id='n1558' href='#n1558'>1558</a>
<a id='n1559' href='#n1559'>1559</a>
<a id='n1560' href='#n1560'>1560</a>
<a id='n1561' href='#n1561'>1561</a>
<a id='n1562' href='#n1562'>1562</a>
<a id='n1563' href='#n1563'>1563</a>
<a id='n1564' href='#n1564'>1564</a>
<a id='n1565' href='#n1565'>1565</a>
<a id='n1566' href='#n1566'>1566</a>
<a id='n1567' href='#n1567'>1567</a>
<a id='n1568' href='#n1568'>1568</a>
<a id='n1569' href='#n1569'>1569</a>
<a id='n1570' href='#n1570'>1570</a>
<a id='n1571' href='#n1571'>1571</a>
<a id='n1572' href='#n1572'>1572</a>
<a id='n1573' href='#n1573'>1573</a>
<a id='n1574' href='#n1574'>1574</a>
<a id='n1575' href='#n1575'>1575</a>
<a id='n1576' href='#n1576'>1576</a>
<a id='n1577' href='#n1577'>1577</a>
<a id='n1578' href='#n1578'>1578</a>
<a id='n1579' href='#n1579'>1579</a>
<a id='n1580' href='#n1580'>1580</a>
<a id='n1581' href='#n1581'>1581</a>
<a id='n1582' href='#n1582'>1582</a>
<a id='n1583' href='#n1583'>1583</a>
<a id='n1584' href='#n1584'>1584</a>
<a id='n1585' href='#n1585'>1585</a>
<a id='n1586' href='#n1586'>1586</a>
<a id='n1587' href='#n1587'>1587</a>
<a id='n1588' href='#n1588'>1588</a>
<a id='n1589' href='#n1589'>1589</a>
<a id='n1590' href='#n1590'>1590</a>
<a id='n1591' href='#n1591'>1591</a>
<a id='n1592' href='#n1592'>1592</a>
<a id='n1593' href='#n1593'>1593</a>
<a id='n1594' href='#n1594'>1594</a>
<a id='n1595' href='#n1595'>1595</a>
<a id='n1596' href='#n1596'>1596</a>
<a id='n1597' href='#n1597'>1597</a>
<a id='n1598' href='#n1598'>1598</a>
<a id='n1599' href='#n1599'>1599</a>
<a id='n1600' href='#n1600'>1600</a>
<a id='n1601' href='#n1601'>1601</a>
<a id='n1602' href='#n1602'>1602</a>
<a id='n1603' href='#n1603'>1603</a>
<a id='n1604' href='#n1604'>1604</a>
<a id='n1605' href='#n1605'>1605</a>
<a id='n1606' href='#n1606'>1606</a>
<a id='n1607' href='#n1607'>1607</a>
<a id='n1608' href='#n1608'>1608</a>
<a id='n1609' href='#n1609'>1609</a>
<a id='n1610' href='#n1610'>1610</a>
<a id='n1611' href='#n1611'>1611</a>
<a id='n1612' href='#n1612'>1612</a>
<a id='n1613' href='#n1613'>1613</a>
<a id='n1614' href='#n1614'>1614</a>
<a id='n1615' href='#n1615'>1615</a>
<a id='n1616' href='#n1616'>1616</a>
<a id='n1617' href='#n1617'>1617</a>
<a id='n1618' href='#n1618'>1618</a>
<a id='n1619' href='#n1619'>1619</a>
<a id='n1620' href='#n1620'>1620</a>
<a id='n1621' href='#n1621'>1621</a>
<a id='n1622' href='#n1622'>1622</a>
<a id='n1623' href='#n1623'>1623</a>
<a id='n1624' href='#n1624'>1624</a>
<a id='n1625' href='#n1625'>1625</a>
<a id='n1626' href='#n1626'>1626</a>
<a id='n1627' href='#n1627'>1627</a>
<a id='n1628' href='#n1628'>1628</a>
<a id='n1629' href='#n1629'>1629</a>
<a id='n1630' href='#n1630'>1630</a>
<a id='n1631' href='#n1631'>1631</a>
<a id='n1632' href='#n1632'>1632</a>
<a id='n1633' href='#n1633'>1633</a>
<a id='n1634' href='#n1634'>1634</a>
<a id='n1635' href='#n1635'>1635</a>
<a id='n1636' href='#n1636'>1636</a>
<a id='n1637' href='#n1637'>1637</a>
<a id='n1638' href='#n1638'>1638</a>
<a id='n1639' href='#n1639'>1639</a>
<a id='n1640' href='#n1640'>1640</a>
<a id='n1641' href='#n1641'>1641</a>
<a id='n1642' href='#n1642'>1642</a>
<a id='n1643' href='#n1643'>1643</a>
<a id='n1644' href='#n1644'>1644</a>
<a id='n1645' href='#n1645'>1645</a>
<a id='n1646' href='#n1646'>1646</a>
<a id='n1647' href='#n1647'>1647</a>
<a id='n1648' href='#n1648'>1648</a>
<a id='n1649' href='#n1649'>1649</a>
<a id='n1650' href='#n1650'>1650</a>
<a id='n1651' href='#n1651'>1651</a>
<a id='n1652' href='#n1652'>1652</a>
<a id='n1653' href='#n1653'>1653</a>
<a id='n1654' href='#n1654'>1654</a>
<a id='n1655' href='#n1655'>1655</a>
<a id='n1656' href='#n1656'>1656</a>
<a id='n1657' href='#n1657'>1657</a>
<a id='n1658' href='#n1658'>1658</a>
<a id='n1659' href='#n1659'>1659</a>
<a id='n1660' href='#n1660'>1660</a>
<a id='n1661' href='#n1661'>1661</a>
<a id='n1662' href='#n1662'>1662</a>
<a id='n1663' href='#n1663'>1663</a>
<a id='n1664' href='#n1664'>1664</a>
<a id='n1665' href='#n1665'>1665</a>
<a id='n1666' href='#n1666'>1666</a>
<a id='n1667' href='#n1667'>1667</a>
<a id='n1668' href='#n1668'>1668</a>
<a id='n1669' href='#n1669'>1669</a>
<a id='n1670' href='#n1670'>1670</a>
<a id='n1671' href='#n1671'>1671</a>
<a id='n1672' href='#n1672'>1672</a>
<a id='n1673' href='#n1673'>1673</a>
<a id='n1674' href='#n1674'>1674</a>
<a id='n1675' href='#n1675'>1675</a>
<a id='n1676' href='#n1676'>1676</a>
<a id='n1677' href='#n1677'>1677</a>
<a id='n1678' href='#n1678'>1678</a>
<a id='n1679' href='#n1679'>1679</a>
<a id='n1680' href='#n1680'>1680</a>
<a id='n1681' href='#n1681'>1681</a>
<a id='n1682' href='#n1682'>1682</a>
<a id='n1683' href='#n1683'>1683</a>
<a id='n1684' href='#n1684'>1684</a>
<a id='n1685' href='#n1685'>1685</a>
<a id='n1686' href='#n1686'>1686</a>
<a id='n1687' href='#n1687'>1687</a>
<a id='n1688' href='#n1688'>1688</a>
<a id='n1689' href='#n1689'>1689</a>
<a id='n1690' href='#n1690'>1690</a>
<a id='n1691' href='#n1691'>1691</a>
<a id='n1692' href='#n1692'>1692</a>
<a id='n1693' href='#n1693'>1693</a>
<a id='n1694' href='#n1694'>1694</a>
<a id='n1695' href='#n1695'>1695</a>
<a id='n1696' href='#n1696'>1696</a>
<a id='n1697' href='#n1697'>1697</a>
<a id='n1698' href='#n1698'>1698</a>
<a id='n1699' href='#n1699'>1699</a>
<a id='n1700' href='#n1700'>1700</a>
<a id='n1701' href='#n1701'>1701</a>
<a id='n1702' href='#n1702'>1702</a>
<a id='n1703' href='#n1703'>1703</a>
<a id='n1704' href='#n1704'>1704</a>
<a id='n1705' href='#n1705'>1705</a>
<a id='n1706' href='#n1706'>1706</a>
<a id='n1707' href='#n1707'>1707</a>
<a id='n1708' href='#n1708'>1708</a>
<a id='n1709' href='#n1709'>1709</a>
<a id='n1710' href='#n1710'>1710</a>
<a id='n1711' href='#n1711'>1711</a>
<a id='n1712' href='#n1712'>1712</a>
<a id='n1713' href='#n1713'>1713</a>
<a id='n1714' href='#n1714'>1714</a>
<a id='n1715' href='#n1715'>1715</a>
<a id='n1716' href='#n1716'>1716</a>
<a id='n1717' href='#n1717'>1717</a>
<a id='n1718' href='#n1718'>1718</a>
<a id='n1719' href='#n1719'>1719</a>
<a id='n1720' href='#n1720'>1720</a>
<a id='n1721' href='#n1721'>1721</a>
<a id='n1722' href='#n1722'>1722</a>
<a id='n1723' href='#n1723'>1723</a>
<a id='n1724' href='#n1724'>1724</a>
<a id='n1725' href='#n1725'>1725</a>
<a id='n1726' href='#n1726'>1726</a>
<a id='n1727' href='#n1727'>1727</a>
<a id='n1728' href='#n1728'>1728</a>
<a id='n1729' href='#n1729'>1729</a>
<a id='n1730' href='#n1730'>1730</a>
<a id='n1731' href='#n1731'>1731</a>
<a id='n1732' href='#n1732'>1732</a>
<a id='n1733' href='#n1733'>1733</a>
<a id='n1734' href='#n1734'>1734</a>
<a id='n1735' href='#n1735'>1735</a>
<a id='n1736' href='#n1736'>1736</a>
<a id='n1737' href='#n1737'>1737</a>
<a id='n1738' href='#n1738'>1738</a>
<a id='n1739' href='#n1739'>1739</a>
<a id='n1740' href='#n1740'>1740</a>
<a id='n1741' href='#n1741'>1741</a>
<a id='n1742' href='#n1742'>1742</a>
<a id='n1743' href='#n1743'>1743</a>
<a id='n1744' href='#n1744'>1744</a>
<a id='n1745' href='#n1745'>1745</a>
<a id='n1746' href='#n1746'>1746</a>
<a id='n1747' href='#n1747'>1747</a>
<a id='n1748' href='#n1748'>1748</a>
<a id='n1749' href='#n1749'>1749</a>
<a id='n1750' href='#n1750'>1750</a>
<a id='n1751' href='#n1751'>1751</a>
<a id='n1752' href='#n1752'>1752</a>
<a id='n1753' href='#n1753'>1753</a>
<a id='n1754' href='#n1754'>1754</a>
<a id='n1755' href='#n1755'>1755</a>
<a id='n1756' href='#n1756'>1756</a>
<a id='n1757' href='#n1757'>1757</a>
<a id='n1758' href='#n1758'>1758</a>
<a id='n1759' href='#n1759'>1759</a>
<a id='n1760' href='#n1760'>1760</a>
<a id='n1761' href='#n1761'>1761</a>
<a id='n1762' href='#n1762'>1762</a>
<a id='n1763' href='#n1763'>1763</a>
<a id='n1764' href='#n1764'>1764</a>
<a id='n1765' href='#n1765'>1765</a>
<a id='n1766' href='#n1766'>1766</a>
<a id='n1767' href='#n1767'>1767</a>
<a id='n1768' href='#n1768'>1768</a>
<a id='n1769' href='#n1769'>1769</a>
<a id='n1770' href='#n1770'>1770</a>
<a id='n1771' href='#n1771'>1771</a>
<a id='n1772' href='#n1772'>1772</a>
<a id='n1773' href='#n1773'>1773</a>
<a id='n1774' href='#n1774'>1774</a>
<a id='n1775' href='#n1775'>1775</a>
<a id='n1776' href='#n1776'>1776</a>
<a id='n1777' href='#n1777'>1777</a>
<a id='n1778' href='#n1778'>1778</a>
<a id='n1779' href='#n1779'>1779</a>
<a id='n1780' href='#n1780'>1780</a>
<a id='n1781' href='#n1781'>1781</a>
<a id='n1782' href='#n1782'>1782</a>
<a id='n1783' href='#n1783'>1783</a>
<a id='n1784' href='#n1784'>1784</a>
<a id='n1785' href='#n1785'>1785</a>
<a id='n1786' href='#n1786'>1786</a>
<a id='n1787' href='#n1787'>1787</a>
<a id='n1788' href='#n1788'>1788</a>
<a id='n1789' href='#n1789'>1789</a>
<a id='n1790' href='#n1790'>1790</a>
<a id='n1791' href='#n1791'>1791</a>
<a id='n1792' href='#n1792'>1792</a>
<a id='n1793' href='#n1793'>1793</a>
<a id='n1794' href='#n1794'>1794</a>
<a id='n1795' href='#n1795'>1795</a>
<a id='n1796' href='#n1796'>1796</a>
<a id='n1797' href='#n1797'>1797</a>
<a id='n1798' href='#n1798'>1798</a>
<a id='n1799' href='#n1799'>1799</a>
<a id='n1800' href='#n1800'>1800</a>
<a id='n1801' href='#n1801'>1801</a>
<a id='n1802' href='#n1802'>1802</a>
<a id='n1803' href='#n1803'>1803</a>
<a id='n1804' href='#n1804'>1804</a>
<a id='n1805' href='#n1805'>1805</a>
<a id='n1806' href='#n1806'>1806</a>
<a id='n1807' href='#n1807'>1807</a>
<a id='n1808' href='#n1808'>1808</a>
<a id='n1809' href='#n1809'>1809</a>
<a id='n1810' href='#n1810'>1810</a>
<a id='n1811' href='#n1811'>1811</a>
<a id='n1812' href='#n1812'>1812</a>
<a id='n1813' href='#n1813'>1813</a>
<a id='n1814' href='#n1814'>1814</a>
<a id='n1815' href='#n1815'>1815</a>
<a id='n1816' href='#n1816'>1816</a>
<a id='n1817' href='#n1817'>1817</a>
<a id='n1818' href='#n1818'>1818</a>
<a id='n1819' href='#n1819'>1819</a>
<a id='n1820' href='#n1820'>1820</a>
<a id='n1821' href='#n1821'>1821</a>
<a id='n1822' href='#n1822'>1822</a>
<a id='n1823' href='#n1823'>1823</a>
<a id='n1824' href='#n1824'>1824</a>
<a id='n1825' href='#n1825'>1825</a>
<a id='n1826' href='#n1826'>1826</a>
<a id='n1827' href='#n1827'>1827</a>
<a id='n1828' href='#n1828'>1828</a>
<a id='n1829' href='#n1829'>1829</a>
<a id='n1830' href='#n1830'>1830</a>
<a id='n1831' href='#n1831'>1831</a>
<a id='n1832' href='#n1832'>1832</a>
<a id='n1833' href='#n1833'>1833</a>
<a id='n1834' href='#n1834'>1834</a>
<a id='n1835' href='#n1835'>1835</a>
<a id='n1836' href='#n1836'>1836</a>
<a id='n1837' href='#n1837'>1837</a>
<a id='n1838' href='#n1838'>1838</a>
<a id='n1839' href='#n1839'>1839</a>
<a id='n1840' href='#n1840'>1840</a>
<a id='n1841' href='#n1841'>1841</a>
<a id='n1842' href='#n1842'>1842</a>
<a id='n1843' href='#n1843'>1843</a>
<a id='n1844' href='#n1844'>1844</a>
<a id='n1845' href='#n1845'>1845</a>
<a id='n1846' href='#n1846'>1846</a>
<a id='n1847' href='#n1847'>1847</a>
<a id='n1848' href='#n1848'>1848</a>
<a id='n1849' href='#n1849'>1849</a>
<a id='n1850' href='#n1850'>1850</a>
<a id='n1851' href='#n1851'>1851</a>
<a id='n1852' href='#n1852'>1852</a>
<a id='n1853' href='#n1853'>1853</a>
<a id='n1854' href='#n1854'>1854</a>
<a id='n1855' href='#n1855'>1855</a>
<a id='n1856' href='#n1856'>1856</a>
<a id='n1857' href='#n1857'>1857</a>
<a id='n1858' href='#n1858'>1858</a>
<a id='n1859' href='#n1859'>1859</a>
<a id='n1860' href='#n1860'>1860</a>
<a id='n1861' href='#n1861'>1861</a>
<a id='n1862' href='#n1862'>1862</a>
<a id='n1863' href='#n1863'>1863</a>
<a id='n1864' href='#n1864'>1864</a>
<a id='n1865' href='#n1865'>1865</a>
<a id='n1866' href='#n1866'>1866</a>
<a id='n1867' href='#n1867'>1867</a>
<a id='n1868' href='#n1868'>1868</a>
<a id='n1869' href='#n1869'>1869</a>
<a id='n1870' href='#n1870'>1870</a>
<a id='n1871' href='#n1871'>1871</a>
<a id='n1872' href='#n1872'>1872</a>
<a id='n1873' href='#n1873'>1873</a>
<a id='n1874' href='#n1874'>1874</a>
<a id='n1875' href='#n1875'>1875</a>
<a id='n1876' href='#n1876'>1876</a>
<a id='n1877' href='#n1877'>1877</a>
<a id='n1878' href='#n1878'>1878</a>
<a id='n1879' href='#n1879'>1879</a>
<a id='n1880' href='#n1880'>1880</a>
<a id='n1881' href='#n1881'>1881</a>
<a id='n1882' href='#n1882'>1882</a>
<a id='n1883' href='#n1883'>1883</a>
<a id='n1884' href='#n1884'>1884</a>
<a id='n1885' href='#n1885'>1885</a>
<a id='n1886' href='#n1886'>1886</a>
<a id='n1887' href='#n1887'>1887</a>
<a id='n1888' href='#n1888'>1888</a>
<a id='n1889' href='#n1889'>1889</a>
<a id='n1890' href='#n1890'>1890</a>
<a id='n1891' href='#n1891'>1891</a>
<a id='n1892' href='#n1892'>1892</a>
<a id='n1893' href='#n1893'>1893</a>
<a id='n1894' href='#n1894'>1894</a>
<a id='n1895' href='#n1895'>1895</a>
<a id='n1896' href='#n1896'>1896</a>
<a id='n1897' href='#n1897'>1897</a>
<a id='n1898' href='#n1898'>1898</a>
<a id='n1899' href='#n1899'>1899</a>
<a id='n1900' href='#n1900'>1900</a>
<a id='n1901' href='#n1901'>1901</a>
<a id='n1902' href='#n1902'>1902</a>
<a id='n1903' href='#n1903'>1903</a>
<a id='n1904' href='#n1904'>1904</a>
<a id='n1905' href='#n1905'>1905</a>
<a id='n1906' href='#n1906'>1906</a>
<a id='n1907' href='#n1907'>1907</a>
<a id='n1908' href='#n1908'>1908</a>
<a id='n1909' href='#n1909'>1909</a>
<a id='n1910' href='#n1910'>1910</a>
<a id='n1911' href='#n1911'>1911</a>
<a id='n1912' href='#n1912'>1912</a>
<a id='n1913' href='#n1913'>1913</a>
<a id='n1914' href='#n1914'>1914</a>
<a id='n1915' href='#n1915'>1915</a>
<a id='n1916' href='#n1916'>1916</a>
<a id='n1917' href='#n1917'>1917</a>
<a id='n1918' href='#n1918'>1918</a>
<a id='n1919' href='#n1919'>1919</a>
<a id='n1920' href='#n1920'>1920</a>
<a id='n1921' href='#n1921'>1921</a>
<a id='n1922' href='#n1922'>1922</a>
<a id='n1923' href='#n1923'>1923</a>
<a id='n1924' href='#n1924'>1924</a>
<a id='n1925' href='#n1925'>1925</a>
<a id='n1926' href='#n1926'>1926</a>
<a id='n1927' href='#n1927'>1927</a>
<a id='n1928' href='#n1928'>1928</a>
<a id='n1929' href='#n1929'>1929</a>
<a id='n1930' href='#n1930'>1930</a>
<a id='n1931' href='#n1931'>1931</a>
<a id='n1932' href='#n1932'>1932</a>
<a id='n1933' href='#n1933'>1933</a>
<a id='n1934' href='#n1934'>1934</a>
<a id='n1935' href='#n1935'>1935</a>
<a id='n1936' href='#n1936'>1936</a>
<a id='n1937' href='#n1937'>1937</a>
<a id='n1938' href='#n1938'>1938</a>
<a id='n1939' href='#n1939'>1939</a>
<a id='n1940' href='#n1940'>1940</a>
<a id='n1941' href='#n1941'>1941</a>
<a id='n1942' href='#n1942'>1942</a>
<a id='n1943' href='#n1943'>1943</a>
<a id='n1944' href='#n1944'>1944</a>
<a id='n1945' href='#n1945'>1945</a>
<a id='n1946' href='#n1946'>1946</a>
<a id='n1947' href='#n1947'>1947</a>
<a id='n1948' href='#n1948'>1948</a>
<a id='n1949' href='#n1949'>1949</a>
<a id='n1950' href='#n1950'>1950</a>
<a id='n1951' href='#n1951'>1951</a>
<a id='n1952' href='#n1952'>1952</a>
<a id='n1953' href='#n1953'>1953</a>
<a id='n1954' href='#n1954'>1954</a>
<a id='n1955' href='#n1955'>1955</a>
<a id='n1956' href='#n1956'>1956</a>
<a id='n1957' href='#n1957'>1957</a>
<a id='n1958' href='#n1958'>1958</a>
<a id='n1959' href='#n1959'>1959</a>
<a id='n1960' href='#n1960'>1960</a>
<a id='n1961' href='#n1961'>1961</a>
<a id='n1962' href='#n1962'>1962</a>
<a id='n1963' href='#n1963'>1963</a>
<a id='n1964' href='#n1964'>1964</a>
<a id='n1965' href='#n1965'>1965</a>
<a id='n1966' href='#n1966'>1966</a>
<a id='n1967' href='#n1967'>1967</a>
<a id='n1968' href='#n1968'>1968</a>
<a id='n1969' href='#n1969'>1969</a>
<a id='n1970' href='#n1970'>1970</a>
<a id='n1971' href='#n1971'>1971</a>
<a id='n1972' href='#n1972'>1972</a>
<a id='n1973' href='#n1973'>1973</a>
<a id='n1974' href='#n1974'>1974</a>
<a id='n1975' href='#n1975'>1975</a>
<a id='n1976' href='#n1976'>1976</a>
<a id='n1977' href='#n1977'>1977</a>
<a id='n1978' href='#n1978'>1978</a>
<a id='n1979' href='#n1979'>1979</a>
<a id='n1980' href='#n1980'>1980</a>
<a id='n1981' href='#n1981'>1981</a>
<a id='n1982' href='#n1982'>1982</a>
<a id='n1983' href='#n1983'>1983</a>
<a id='n1984' href='#n1984'>1984</a>
<a id='n1985' href='#n1985'>1985</a>
<a id='n1986' href='#n1986'>1986</a>
<a id='n1987' href='#n1987'>1987</a>
<a id='n1988' href='#n1988'>1988</a>
<a id='n1989' href='#n1989'>1989</a>
<a id='n1990' href='#n1990'>1990</a>
<a id='n1991' href='#n1991'>1991</a>
<a id='n1992' href='#n1992'>1992</a>
<a id='n1993' href='#n1993'>1993</a>
<a id='n1994' href='#n1994'>1994</a>
<a id='n1995' href='#n1995'>1995</a>
<a id='n1996' href='#n1996'>1996</a>
<a id='n1997' href='#n1997'>1997</a>
<a id='n1998' href='#n1998'>1998</a>
<a id='n1999' href='#n1999'>1999</a>
<a id='n2000' href='#n2000'>2000</a>
<a id='n2001' href='#n2001'>2001</a>
<a id='n2002' href='#n2002'>2002</a>
<a id='n2003' href='#n2003'>2003</a>
<a id='n2004' href='#n2004'>2004</a>
<a id='n2005' href='#n2005'>2005</a>
<a id='n2006' href='#n2006'>2006</a>
<a id='n2007' href='#n2007'>2007</a>
<a id='n2008' href='#n2008'>2008</a>
<a id='n2009' href='#n2009'>2009</a>
<a id='n2010' href='#n2010'>2010</a>
<a id='n2011' href='#n2011'>2011</a>
<a id='n2012' href='#n2012'>2012</a>
<a id='n2013' href='#n2013'>2013</a>
<a id='n2014' href='#n2014'>2014</a>
<a id='n2015' href='#n2015'>2015</a>
<a id='n2016' href='#n2016'>2016</a>
<a id='n2017' href='#n2017'>2017</a>
<a id='n2018' href='#n2018'>2018</a>
<a id='n2019' href='#n2019'>2019</a>
<a id='n2020' href='#n2020'>2020</a>
<a id='n2021' href='#n2021'>2021</a>
<a id='n2022' href='#n2022'>2022</a>
<a id='n2023' href='#n2023'>2023</a>
<a id='n2024' href='#n2024'>2024</a>
<a id='n2025' href='#n2025'>2025</a>
<a id='n2026' href='#n2026'>2026</a>
<a id='n2027' href='#n2027'>2027</a>
<a id='n2028' href='#n2028'>2028</a>
<a id='n2029' href='#n2029'>2029</a>
<a id='n2030' href='#n2030'>2030</a>
<a id='n2031' href='#n2031'>2031</a>
<a id='n2032' href='#n2032'>2032</a>
<a id='n2033' href='#n2033'>2033</a>
<a id='n2034' href='#n2034'>2034</a>
<a id='n2035' href='#n2035'>2035</a>
<a id='n2036' href='#n2036'>2036</a>
<a id='n2037' href='#n2037'>2037</a>
<a id='n2038' href='#n2038'>2038</a>
<a id='n2039' href='#n2039'>2039</a>
<a id='n2040' href='#n2040'>2040</a>
<a id='n2041' href='#n2041'>2041</a>
<a id='n2042' href='#n2042'>2042</a>
<a id='n2043' href='#n2043'>2043</a>
<a id='n2044' href='#n2044'>2044</a>
<a id='n2045' href='#n2045'>2045</a>
<a id='n2046' href='#n2046'>2046</a>
<a id='n2047' href='#n2047'>2047</a>
<a id='n2048' href='#n2048'>2048</a>
<a id='n2049' href='#n2049'>2049</a>
<a id='n2050' href='#n2050'>2050</a>
<a id='n2051' href='#n2051'>2051</a>
<a id='n2052' href='#n2052'>2052</a>
<a id='n2053' href='#n2053'>2053</a>
<a id='n2054' href='#n2054'>2054</a>
<a id='n2055' href='#n2055'>2055</a>
<a id='n2056' href='#n2056'>2056</a>
<a id='n2057' href='#n2057'>2057</a>
<a id='n2058' href='#n2058'>2058</a>
<a id='n2059' href='#n2059'>2059</a>
<a id='n2060' href='#n2060'>2060</a>
<a id='n2061' href='#n2061'>2061</a>
<a id='n2062' href='#n2062'>2062</a>
<a id='n2063' href='#n2063'>2063</a>
<a id='n2064' href='#n2064'>2064</a>
<a id='n2065' href='#n2065'>2065</a>
<a id='n2066' href='#n2066'>2066</a>
<a id='n2067' href='#n2067'>2067</a>
<a id='n2068' href='#n2068'>2068</a>
<a id='n2069' href='#n2069'>2069</a>
<a id='n2070' href='#n2070'>2070</a>
<a id='n2071' href='#n2071'>2071</a>
<a id='n2072' href='#n2072'>2072</a>
<a id='n2073' href='#n2073'>2073</a>
<a id='n2074' href='#n2074'>2074</a>
<a id='n2075' href='#n2075'>2075</a>
<a id='n2076' href='#n2076'>2076</a>
<a id='n2077' href='#n2077'>2077</a>
<a id='n2078' href='#n2078'>2078</a>
<a id='n2079' href='#n2079'>2079</a>
<a id='n2080' href='#n2080'>2080</a>
<a id='n2081' href='#n2081'>2081</a>
<a id='n2082' href='#n2082'>2082</a>
<a id='n2083' href='#n2083'>2083</a>
<a id='n2084' href='#n2084'>2084</a>
<a id='n2085' href='#n2085'>2085</a>
<a id='n2086' href='#n2086'>2086</a>
<a id='n2087' href='#n2087'>2087</a>
<a id='n2088' href='#n2088'>2088</a>
<a id='n2089' href='#n2089'>2089</a>
<a id='n2090' href='#n2090'>2090</a>
<a id='n2091' href='#n2091'>2091</a>
<a id='n2092' href='#n2092'>2092</a>
<a id='n2093' href='#n2093'>2093</a>
<a id='n2094' href='#n2094'>2094</a>
<a id='n2095' href='#n2095'>2095</a>
<a id='n2096' href='#n2096'>2096</a>
<a id='n2097' href='#n2097'>2097</a>
<a id='n2098' href='#n2098'>2098</a>
<a id='n2099' href='#n2099'>2099</a>
<a id='n2100' href='#n2100'>2100</a>
<a id='n2101' href='#n2101'>2101</a>
<a id='n2102' href='#n2102'>2102</a>
<a id='n2103' href='#n2103'>2103</a>
<a id='n2104' href='#n2104'>2104</a>
<a id='n2105' href='#n2105'>2105</a>
<a id='n2106' href='#n2106'>2106</a>
<a id='n2107' href='#n2107'>2107</a>
<a id='n2108' href='#n2108'>2108</a>
<a id='n2109' href='#n2109'>2109</a>
<a id='n2110' href='#n2110'>2110</a>
<a id='n2111' href='#n2111'>2111</a>
<a id='n2112' href='#n2112'>2112</a>
<a id='n2113' href='#n2113'>2113</a>
<a id='n2114' href='#n2114'>2114</a>
<a id='n2115' href='#n2115'>2115</a>
<a id='n2116' href='#n2116'>2116</a>
<a id='n2117' href='#n2117'>2117</a>
<a id='n2118' href='#n2118'>2118</a>
<a id='n2119' href='#n2119'>2119</a>
<a id='n2120' href='#n2120'>2120</a>
<a id='n2121' href='#n2121'>2121</a>
<a id='n2122' href='#n2122'>2122</a>
<a id='n2123' href='#n2123'>2123</a>
<a id='n2124' href='#n2124'>2124</a>
<a id='n2125' href='#n2125'>2125</a>
<a id='n2126' href='#n2126'>2126</a>
<a id='n2127' href='#n2127'>2127</a>
<a id='n2128' href='#n2128'>2128</a>
<a id='n2129' href='#n2129'>2129</a>
<a id='n2130' href='#n2130'>2130</a>
<a id='n2131' href='#n2131'>2131</a>
<a id='n2132' href='#n2132'>2132</a>
<a id='n2133' href='#n2133'>2133</a>
<a id='n2134' href='#n2134'>2134</a>
<a id='n2135' href='#n2135'>2135</a>
<a id='n2136' href='#n2136'>2136</a>
<a id='n2137' href='#n2137'>2137</a>
<a id='n2138' href='#n2138'>2138</a>
<a id='n2139' href='#n2139'>2139</a>
<a id='n2140' href='#n2140'>2140</a>
<a id='n2141' href='#n2141'>2141</a>
<a id='n2142' href='#n2142'>2142</a>
<a id='n2143' href='#n2143'>2143</a>
<a id='n2144' href='#n2144'>2144</a>
<a id='n2145' href='#n2145'>2145</a>
<a id='n2146' href='#n2146'>2146</a>
<a id='n2147' href='#n2147'>2147</a>
<a id='n2148' href='#n2148'>2148</a>
<a id='n2149' href='#n2149'>2149</a>
<a id='n2150' href='#n2150'>2150</a>
<a id='n2151' href='#n2151'>2151</a>
<a id='n2152' href='#n2152'>2152</a>
<a id='n2153' href='#n2153'>2153</a>
<a id='n2154' href='#n2154'>2154</a>
<a id='n2155' href='#n2155'>2155</a>
<a id='n2156' href='#n2156'>2156</a>
<a id='n2157' href='#n2157'>2157</a>
<a id='n2158' href='#n2158'>2158</a>
<a id='n2159' href='#n2159'>2159</a>
<a id='n2160' href='#n2160'>2160</a>
<a id='n2161' href='#n2161'>2161</a>
<a id='n2162' href='#n2162'>2162</a>
<a id='n2163' href='#n2163'>2163</a>
<a id='n2164' href='#n2164'>2164</a>
<a id='n2165' href='#n2165'>2165</a>
<a id='n2166' href='#n2166'>2166</a>
<a id='n2167' href='#n2167'>2167</a>
<a id='n2168' href='#n2168'>2168</a>
<a id='n2169' href='#n2169'>2169</a>
<a id='n2170' href='#n2170'>2170</a>
<a id='n2171' href='#n2171'>2171</a>
<a id='n2172' href='#n2172'>2172</a>
<a id='n2173' href='#n2173'>2173</a>
<a id='n2174' href='#n2174'>2174</a>
<a id='n2175' href='#n2175'>2175</a>
<a id='n2176' href='#n2176'>2176</a>
<a id='n2177' href='#n2177'>2177</a>
<a id='n2178' href='#n2178'>2178</a>
<a id='n2179' href='#n2179'>2179</a>
<a id='n2180' href='#n2180'>2180</a>
<a id='n2181' href='#n2181'>2181</a>
<a id='n2182' href='#n2182'>2182</a>
<a id='n2183' href='#n2183'>2183</a>
<a id='n2184' href='#n2184'>2184</a>
<a id='n2185' href='#n2185'>2185</a>
<a id='n2186' href='#n2186'>2186</a>
<a id='n2187' href='#n2187'>2187</a>
<a id='n2188' href='#n2188'>2188</a>
<a id='n2189' href='#n2189'>2189</a>
<a id='n2190' href='#n2190'>2190</a>
<a id='n2191' href='#n2191'>2191</a>
<a id='n2192' href='#n2192'>2192</a>
<a id='n2193' href='#n2193'>2193</a>
<a id='n2194' href='#n2194'>2194</a>
<a id='n2195' href='#n2195'>2195</a>
<a id='n2196' href='#n2196'>2196</a>
<a id='n2197' href='#n2197'>2197</a>
<a id='n2198' href='#n2198'>2198</a>
<a id='n2199' href='#n2199'>2199</a>
<a id='n2200' href='#n2200'>2200</a>
<a id='n2201' href='#n2201'>2201</a>
<a id='n2202' href='#n2202'>2202</a>
<a id='n2203' href='#n2203'>2203</a>
<a id='n2204' href='#n2204'>2204</a>
<a id='n2205' href='#n2205'>2205</a>
<a id='n2206' href='#n2206'>2206</a>
<a id='n2207' href='#n2207'>2207</a>
<a id='n2208' href='#n2208'>2208</a>
<a id='n2209' href='#n2209'>2209</a>
<a id='n2210' href='#n2210'>2210</a>
<a id='n2211' href='#n2211'>2211</a>
<a id='n2212' href='#n2212'>2212</a>
<a id='n2213' href='#n2213'>2213</a>
<a id='n2214' href='#n2214'>2214</a>
<a id='n2215' href='#n2215'>2215</a>
<a id='n2216' href='#n2216'>2216</a>
<a id='n2217' href='#n2217'>2217</a>
<a id='n2218' href='#n2218'>2218</a>
<a id='n2219' href='#n2219'>2219</a>
<a id='n2220' href='#n2220'>2220</a>
<a id='n2221' href='#n2221'>2221</a>
<a id='n2222' href='#n2222'>2222</a>
<a id='n2223' href='#n2223'>2223</a>
<a id='n2224' href='#n2224'>2224</a>
<a id='n2225' href='#n2225'>2225</a>
<a id='n2226' href='#n2226'>2226</a>
<a id='n2227' href='#n2227'>2227</a>
<a id='n2228' href='#n2228'>2228</a>
<a id='n2229' href='#n2229'>2229</a>
<a id='n2230' href='#n2230'>2230</a>
<a id='n2231' href='#n2231'>2231</a>
<a id='n2232' href='#n2232'>2232</a>
<a id='n2233' href='#n2233'>2233</a>
<a id='n2234' href='#n2234'>2234</a>
<a id='n2235' href='#n2235'>2235</a>
<a id='n2236' href='#n2236'>2236</a>
<a id='n2237' href='#n2237'>2237</a>
<a id='n2238' href='#n2238'>2238</a>
<a id='n2239' href='#n2239'>2239</a>
<a id='n2240' href='#n2240'>2240</a>
<a id='n2241' href='#n2241'>2241</a>
<a id='n2242' href='#n2242'>2242</a>
<a id='n2243' href='#n2243'>2243</a>
<a id='n2244' href='#n2244'>2244</a>
<a id='n2245' href='#n2245'>2245</a>
<a id='n2246' href='#n2246'>2246</a>
<a id='n2247' href='#n2247'>2247</a>
<a id='n2248' href='#n2248'>2248</a>
<a id='n2249' href='#n2249'>2249</a>
<a id='n2250' href='#n2250'>2250</a>
<a id='n2251' href='#n2251'>2251</a>
<a id='n2252' href='#n2252'>2252</a>
<a id='n2253' href='#n2253'>2253</a>
<a id='n2254' href='#n2254'>2254</a>
<a id='n2255' href='#n2255'>2255</a>
<a id='n2256' href='#n2256'>2256</a>
<a id='n2257' href='#n2257'>2257</a>
<a id='n2258' href='#n2258'>2258</a>
<a id='n2259' href='#n2259'>2259</a>
<a id='n2260' href='#n2260'>2260</a>
<a id='n2261' href='#n2261'>2261</a>
<a id='n2262' href='#n2262'>2262</a>
<a id='n2263' href='#n2263'>2263</a>
<a id='n2264' href='#n2264'>2264</a>
<a id='n2265' href='#n2265'>2265</a>
<a id='n2266' href='#n2266'>2266</a>
<a id='n2267' href='#n2267'>2267</a>
<a id='n2268' href='#n2268'>2268</a>
<a id='n2269' href='#n2269'>2269</a>
<a id='n2270' href='#n2270'>2270</a>
<a id='n2271' href='#n2271'>2271</a>
<a id='n2272' href='#n2272'>2272</a>
<a id='n2273' href='#n2273'>2273</a>
<a id='n2274' href='#n2274'>2274</a>
<a id='n2275' href='#n2275'>2275</a>
<a id='n2276' href='#n2276'>2276</a>
<a id='n2277' href='#n2277'>2277</a>
<a id='n2278' href='#n2278'>2278</a>
<a id='n2279' href='#n2279'>2279</a>
<a id='n2280' href='#n2280'>2280</a>
<a id='n2281' href='#n2281'>2281</a>
<a id='n2282' href='#n2282'>2282</a>
<a id='n2283' href='#n2283'>2283</a>
<a id='n2284' href='#n2284'>2284</a>
<a id='n2285' href='#n2285'>2285</a>
<a id='n2286' href='#n2286'>2286</a>
<a id='n2287' href='#n2287'>2287</a>
<a id='n2288' href='#n2288'>2288</a>
<a id='n2289' href='#n2289'>2289</a>
<a id='n2290' href='#n2290'>2290</a>
<a id='n2291' href='#n2291'>2291</a>
<a id='n2292' href='#n2292'>2292</a>
<a id='n2293' href='#n2293'>2293</a>
<a id='n2294' href='#n2294'>2294</a>
<a id='n2295' href='#n2295'>2295</a>
<a id='n2296' href='#n2296'>2296</a>
<a id='n2297' href='#n2297'>2297</a>
<a id='n2298' href='#n2298'>2298</a>
<a id='n2299' href='#n2299'>2299</a>
<a id='n2300' href='#n2300'>2300</a>
<a id='n2301' href='#n2301'>2301</a>
<a id='n2302' href='#n2302'>2302</a>
<a id='n2303' href='#n2303'>2303</a>
<a id='n2304' href='#n2304'>2304</a>
<a id='n2305' href='#n2305'>2305</a>
<a id='n2306' href='#n2306'>2306</a>
<a id='n2307' href='#n2307'>2307</a>
<a id='n2308' href='#n2308'>2308</a>
<a id='n2309' href='#n2309'>2309</a>
<a id='n2310' href='#n2310'>2310</a>
<a id='n2311' href='#n2311'>2311</a>
<a id='n2312' href='#n2312'>2312</a>
<a id='n2313' href='#n2313'>2313</a>
<a id='n2314' href='#n2314'>2314</a>
<a id='n2315' href='#n2315'>2315</a>
<a id='n2316' href='#n2316'>2316</a>
<a id='n2317' href='#n2317'>2317</a>
<a id='n2318' href='#n2318'>2318</a>
<a id='n2319' href='#n2319'>2319</a>
<a id='n2320' href='#n2320'>2320</a>
<a id='n2321' href='#n2321'>2321</a>
<a id='n2322' href='#n2322'>2322</a>
<a id='n2323' href='#n2323'>2323</a>
<a id='n2324' href='#n2324'>2324</a>
<a id='n2325' href='#n2325'>2325</a>
<a id='n2326' href='#n2326'>2326</a>
<a id='n2327' href='#n2327'>2327</a>
<a id='n2328' href='#n2328'>2328</a>
<a id='n2329' href='#n2329'>2329</a>
<a id='n2330' href='#n2330'>2330</a>
<a id='n2331' href='#n2331'>2331</a>
<a id='n2332' href='#n2332'>2332</a>
<a id='n2333' href='#n2333'>2333</a>
<a id='n2334' href='#n2334'>2334</a>
<a id='n2335' href='#n2335'>2335</a>
<a id='n2336' href='#n2336'>2336</a>
<a id='n2337' href='#n2337'>2337</a>
<a id='n2338' href='#n2338'>2338</a>
<a id='n2339' href='#n2339'>2339</a>
<a id='n2340' href='#n2340'>2340</a>
<a id='n2341' href='#n2341'>2341</a>
<a id='n2342' href='#n2342'>2342</a>
<a id='n2343' href='#n2343'>2343</a>
<a id='n2344' href='#n2344'>2344</a>
<a id='n2345' href='#n2345'>2345</a>
<a id='n2346' href='#n2346'>2346</a>
<a id='n2347' href='#n2347'>2347</a>
<a id='n2348' href='#n2348'>2348</a>
<a id='n2349' href='#n2349'>2349</a>
<a id='n2350' href='#n2350'>2350</a>
<a id='n2351' href='#n2351'>2351</a>
<a id='n2352' href='#n2352'>2352</a>
<a id='n2353' href='#n2353'>2353</a>
<a id='n2354' href='#n2354'>2354</a>
<a id='n2355' href='#n2355'>2355</a>
<a id='n2356' href='#n2356'>2356</a>
<a id='n2357' href='#n2357'>2357</a>
<a id='n2358' href='#n2358'>2358</a>
<a id='n2359' href='#n2359'>2359</a>
<a id='n2360' href='#n2360'>2360</a>
<a id='n2361' href='#n2361'>2361</a>
<a id='n2362' href='#n2362'>2362</a>
<a id='n2363' href='#n2363'>2363</a>
<a id='n2364' href='#n2364'>2364</a>
<a id='n2365' href='#n2365'>2365</a>
<a id='n2366' href='#n2366'>2366</a>
<a id='n2367' href='#n2367'>2367</a>
<a id='n2368' href='#n2368'>2368</a>
<a id='n2369' href='#n2369'>2369</a>
<a id='n2370' href='#n2370'>2370</a>
<a id='n2371' href='#n2371'>2371</a>
<a id='n2372' href='#n2372'>2372</a>
<a id='n2373' href='#n2373'>2373</a>
<a id='n2374' href='#n2374'>2374</a>
<a id='n2375' href='#n2375'>2375</a>
<a id='n2376' href='#n2376'>2376</a>
<a id='n2377' href='#n2377'>2377</a>
<a id='n2378' href='#n2378'>2378</a>
<a id='n2379' href='#n2379'>2379</a>
<a id='n2380' href='#n2380'>2380</a>
<a id='n2381' href='#n2381'>2381</a>
<a id='n2382' href='#n2382'>2382</a>
<a id='n2383' href='#n2383'>2383</a>
<a id='n2384' href='#n2384'>2384</a>
<a id='n2385' href='#n2385'>2385</a>
<a id='n2386' href='#n2386'>2386</a>
<a id='n2387' href='#n2387'>2387</a>
<a id='n2388' href='#n2388'>2388</a>
<a id='n2389' href='#n2389'>2389</a>
<a id='n2390' href='#n2390'>2390</a>
<a id='n2391' href='#n2391'>2391</a>
<a id='n2392' href='#n2392'>2392</a>
<a id='n2393' href='#n2393'>2393</a>
<a id='n2394' href='#n2394'>2394</a>
<a id='n2395' href='#n2395'>2395</a>
<a id='n2396' href='#n2396'>2396</a>
<a id='n2397' href='#n2397'>2397</a>
<a id='n2398' href='#n2398'>2398</a>
<a id='n2399' href='#n2399'>2399</a>
<a id='n2400' href='#n2400'>2400</a>
<a id='n2401' href='#n2401'>2401</a>
<a id='n2402' href='#n2402'>2402</a>
<a id='n2403' href='#n2403'>2403</a>
<a id='n2404' href='#n2404'>2404</a>
<a id='n2405' href='#n2405'>2405</a>
<a id='n2406' href='#n2406'>2406</a>
<a id='n2407' href='#n2407'>2407</a>
<a id='n2408' href='#n2408'>2408</a>
<a id='n2409' href='#n2409'>2409</a>
<a id='n2410' href='#n2410'>2410</a>
<a id='n2411' href='#n2411'>2411</a>
<a id='n2412' href='#n2412'>2412</a>
<a id='n2413' href='#n2413'>2413</a>
<a id='n2414' href='#n2414'>2414</a>
<a id='n2415' href='#n2415'>2415</a>
<a id='n2416' href='#n2416'>2416</a>
<a id='n2417' href='#n2417'>2417</a>
<a id='n2418' href='#n2418'>2418</a>
<a id='n2419' href='#n2419'>2419</a>
<a id='n2420' href='#n2420'>2420</a>
<a id='n2421' href='#n2421'>2421</a>
<a id='n2422' href='#n2422'>2422</a>
<a id='n2423' href='#n2423'>2423</a>
<a id='n2424' href='#n2424'>2424</a>
<a id='n2425' href='#n2425'>2425</a>
<a id='n2426' href='#n2426'>2426</a>
<a id='n2427' href='#n2427'>2427</a>
<a id='n2428' href='#n2428'>2428</a>
<a id='n2429' href='#n2429'>2429</a>
<a id='n2430' href='#n2430'>2430</a>
<a id='n2431' href='#n2431'>2431</a>
<a id='n2432' href='#n2432'>2432</a>
<a id='n2433' href='#n2433'>2433</a>
<a id='n2434' href='#n2434'>2434</a>
<a id='n2435' href='#n2435'>2435</a>
<a id='n2436' href='#n2436'>2436</a>
<a id='n2437' href='#n2437'>2437</a>
<a id='n2438' href='#n2438'>2438</a>
<a id='n2439' href='#n2439'>2439</a>
<a id='n2440' href='#n2440'>2440</a>
<a id='n2441' href='#n2441'>2441</a>
<a id='n2442' href='#n2442'>2442</a>
<a id='n2443' href='#n2443'>2443</a>
<a id='n2444' href='#n2444'>2444</a>
<a id='n2445' href='#n2445'>2445</a>
<a id='n2446' href='#n2446'>2446</a>
<a id='n2447' href='#n2447'>2447</a>
<a id='n2448' href='#n2448'>2448</a>
<a id='n2449' href='#n2449'>2449</a>
<a id='n2450' href='#n2450'>2450</a>
<a id='n2451' href='#n2451'>2451</a>
<a id='n2452' href='#n2452'>2452</a>
<a id='n2453' href='#n2453'>2453</a>
<a id='n2454' href='#n2454'>2454</a>
<a id='n2455' href='#n2455'>2455</a>
<a id='n2456' href='#n2456'>2456</a>
<a id='n2457' href='#n2457'>2457</a>
<a id='n2458' href='#n2458'>2458</a>
<a id='n2459' href='#n2459'>2459</a>
<a id='n2460' href='#n2460'>2460</a>
<a id='n2461' href='#n2461'>2461</a>
<a id='n2462' href='#n2462'>2462</a>
<a id='n2463' href='#n2463'>2463</a>
<a id='n2464' href='#n2464'>2464</a>
<a id='n2465' href='#n2465'>2465</a>
<a id='n2466' href='#n2466'>2466</a>
<a id='n2467' href='#n2467'>2467</a>
<a id='n2468' href='#n2468'>2468</a>
<a id='n2469' href='#n2469'>2469</a>
<a id='n2470' href='#n2470'>2470</a>
<a id='n2471' href='#n2471'>2471</a>
<a id='n2472' href='#n2472'>2472</a>
<a id='n2473' href='#n2473'>2473</a>
<a id='n2474' href='#n2474'>2474</a>
<a id='n2475' href='#n2475'>2475</a>
<a id='n2476' href='#n2476'>2476</a>
<a id='n2477' href='#n2477'>2477</a>
<a id='n2478' href='#n2478'>2478</a>
<a id='n2479' href='#n2479'>2479</a>
<a id='n2480' href='#n2480'>2480</a>
<a id='n2481' href='#n2481'>2481</a>
<a id='n2482' href='#n2482'>2482</a>
<a id='n2483' href='#n2483'>2483</a>
<a id='n2484' href='#n2484'>2484</a>
<a id='n2485' href='#n2485'>2485</a>
<a id='n2486' href='#n2486'>2486</a>
<a id='n2487' href='#n2487'>2487</a>
<a id='n2488' href='#n2488'>2488</a>
<a id='n2489' href='#n2489'>2489</a>
<a id='n2490' href='#n2490'>2490</a>
<a id='n2491' href='#n2491'>2491</a>
<a id='n2492' href='#n2492'>2492</a>
<a id='n2493' href='#n2493'>2493</a>
<a id='n2494' href='#n2494'>2494</a>
<a id='n2495' href='#n2495'>2495</a>
<a id='n2496' href='#n2496'>2496</a>
<a id='n2497' href='#n2497'>2497</a>
<a id='n2498' href='#n2498'>2498</a>
<a id='n2499' href='#n2499'>2499</a>
<a id='n2500' href='#n2500'>2500</a>
<a id='n2501' href='#n2501'>2501</a>
<a id='n2502' href='#n2502'>2502</a>
<a id='n2503' href='#n2503'>2503</a>
<a id='n2504' href='#n2504'>2504</a>
<a id='n2505' href='#n2505'>2505</a>
<a id='n2506' href='#n2506'>2506</a>
<a id='n2507' href='#n2507'>2507</a>
<a id='n2508' href='#n2508'>2508</a>
<a id='n2509' href='#n2509'>2509</a>
<a id='n2510' href='#n2510'>2510</a>
<a id='n2511' href='#n2511'>2511</a>
<a id='n2512' href='#n2512'>2512</a>
<a id='n2513' href='#n2513'>2513</a>
<a id='n2514' href='#n2514'>2514</a>
<a id='n2515' href='#n2515'>2515</a>
<a id='n2516' href='#n2516'>2516</a>
<a id='n2517' href='#n2517'>2517</a>
<a id='n2518' href='#n2518'>2518</a>
<a id='n2519' href='#n2519'>2519</a>
<a id='n2520' href='#n2520'>2520</a>
<a id='n2521' href='#n2521'>2521</a>
<a id='n2522' href='#n2522'>2522</a>
<a id='n2523' href='#n2523'>2523</a>
<a id='n2524' href='#n2524'>2524</a>
<a id='n2525' href='#n2525'>2525</a>
<a id='n2526' href='#n2526'>2526</a>
<a id='n2527' href='#n2527'>2527</a>
<a id='n2528' href='#n2528'>2528</a>
<a id='n2529' href='#n2529'>2529</a>
<a id='n2530' href='#n2530'>2530</a>
<a id='n2531' href='#n2531'>2531</a>
<a id='n2532' href='#n2532'>2532</a>
<a id='n2533' href='#n2533'>2533</a>
<a id='n2534' href='#n2534'>2534</a>
<a id='n2535' href='#n2535'>2535</a>
<a id='n2536' href='#n2536'>2536</a>
<a id='n2537' href='#n2537'>2537</a>
<a id='n2538' href='#n2538'>2538</a>
<a id='n2539' href='#n2539'>2539</a>
<a id='n2540' href='#n2540'>2540</a>
<a id='n2541' href='#n2541'>2541</a>
<a id='n2542' href='#n2542'>2542</a>
<a id='n2543' href='#n2543'>2543</a>
<a id='n2544' href='#n2544'>2544</a>
<a id='n2545' href='#n2545'>2545</a>
<a id='n2546' href='#n2546'>2546</a>
<a id='n2547' href='#n2547'>2547</a>
<a id='n2548' href='#n2548'>2548</a>
<a id='n2549' href='#n2549'>2549</a>
<a id='n2550' href='#n2550'>2550</a>
<a id='n2551' href='#n2551'>2551</a>
<a id='n2552' href='#n2552'>2552</a>
<a id='n2553' href='#n2553'>2553</a>
<a id='n2554' href='#n2554'>2554</a>
<a id='n2555' href='#n2555'>2555</a>
<a id='n2556' href='#n2556'>2556</a>
<a id='n2557' href='#n2557'>2557</a>
<a id='n2558' href='#n2558'>2558</a>
<a id='n2559' href='#n2559'>2559</a>
<a id='n2560' href='#n2560'>2560</a>
<a id='n2561' href='#n2561'>2561</a>
<a id='n2562' href='#n2562'>2562</a>
<a id='n2563' href='#n2563'>2563</a>
<a id='n2564' href='#n2564'>2564</a>
<a id='n2565' href='#n2565'>2565</a>
<a id='n2566' href='#n2566'>2566</a>
<a id='n2567' href='#n2567'>2567</a>
<a id='n2568' href='#n2568'>2568</a>
<a id='n2569' href='#n2569'>2569</a>
<a id='n2570' href='#n2570'>2570</a>
<a id='n2571' href='#n2571'>2571</a>
<a id='n2572' href='#n2572'>2572</a>
<a id='n2573' href='#n2573'>2573</a>
<a id='n2574' href='#n2574'>2574</a>
<a id='n2575' href='#n2575'>2575</a>
<a id='n2576' href='#n2576'>2576</a>
<a id='n2577' href='#n2577'>2577</a>
<a id='n2578' href='#n2578'>2578</a>
<a id='n2579' href='#n2579'>2579</a>
<a id='n2580' href='#n2580'>2580</a>
<a id='n2581' href='#n2581'>2581</a>
<a id='n2582' href='#n2582'>2582</a>
<a id='n2583' href='#n2583'>2583</a>
<a id='n2584' href='#n2584'>2584</a>
<a id='n2585' href='#n2585'>2585</a>
<a id='n2586' href='#n2586'>2586</a>
<a id='n2587' href='#n2587'>2587</a>
<a id='n2588' href='#n2588'>2588</a>
<a id='n2589' href='#n2589'>2589</a>
<a id='n2590' href='#n2590'>2590</a>
<a id='n2591' href='#n2591'>2591</a>
<a id='n2592' href='#n2592'>2592</a>
<a id='n2593' href='#n2593'>2593</a>
<a id='n2594' href='#n2594'>2594</a>
<a id='n2595' href='#n2595'>2595</a>
<a id='n2596' href='#n2596'>2596</a>
<a id='n2597' href='#n2597'>2597</a>
<a id='n2598' href='#n2598'>2598</a>
<a id='n2599' href='#n2599'>2599</a>
<a id='n2600' href='#n2600'>2600</a>
<a id='n2601' href='#n2601'>2601</a>
<a id='n2602' href='#n2602'>2602</a>
<a id='n2603' href='#n2603'>2603</a>
<a id='n2604' href='#n2604'>2604</a>
<a id='n2605' href='#n2605'>2605</a>
<a id='n2606' href='#n2606'>2606</a>
<a id='n2607' href='#n2607'>2607</a>
<a id='n2608' href='#n2608'>2608</a>
<a id='n2609' href='#n2609'>2609</a>
<a id='n2610' href='#n2610'>2610</a>
<a id='n2611' href='#n2611'>2611</a>
<a id='n2612' href='#n2612'>2612</a>
<a id='n2613' href='#n2613'>2613</a>
<a id='n2614' href='#n2614'>2614</a>
<a id='n2615' href='#n2615'>2615</a>
<a id='n2616' href='#n2616'>2616</a>
<a id='n2617' href='#n2617'>2617</a>
<a id='n2618' href='#n2618'>2618</a>
<a id='n2619' href='#n2619'>2619</a>
<a id='n2620' href='#n2620'>2620</a>
<a id='n2621' href='#n2621'>2621</a>
<a id='n2622' href='#n2622'>2622</a>
<a id='n2623' href='#n2623'>2623</a>
<a id='n2624' href='#n2624'>2624</a>
<a id='n2625' href='#n2625'>2625</a>
<a id='n2626' href='#n2626'>2626</a>
<a id='n2627' href='#n2627'>2627</a>
<a id='n2628' href='#n2628'>2628</a>
<a id='n2629' href='#n2629'>2629</a>
<a id='n2630' href='#n2630'>2630</a>
<a id='n2631' href='#n2631'>2631</a>
<a id='n2632' href='#n2632'>2632</a>
<a id='n2633' href='#n2633'>2633</a>
<a id='n2634' href='#n2634'>2634</a>
<a id='n2635' href='#n2635'>2635</a>
<a id='n2636' href='#n2636'>2636</a>
<a id='n2637' href='#n2637'>2637</a>
<a id='n2638' href='#n2638'>2638</a>
<a id='n2639' href='#n2639'>2639</a>
<a id='n2640' href='#n2640'>2640</a>
<a id='n2641' href='#n2641'>2641</a>
<a id='n2642' href='#n2642'>2642</a>
<a id='n2643' href='#n2643'>2643</a>
<a id='n2644' href='#n2644'>2644</a>
<a id='n2645' href='#n2645'>2645</a>
<a id='n2646' href='#n2646'>2646</a>
<a id='n2647' href='#n2647'>2647</a>
<a id='n2648' href='#n2648'>2648</a>
<a id='n2649' href='#n2649'>2649</a>
<a id='n2650' href='#n2650'>2650</a>
<a id='n2651' href='#n2651'>2651</a>
<a id='n2652' href='#n2652'>2652</a>
<a id='n2653' href='#n2653'>2653</a>
<a id='n2654' href='#n2654'>2654</a>
<a id='n2655' href='#n2655'>2655</a>
<a id='n2656' href='#n2656'>2656</a>
<a id='n2657' href='#n2657'>2657</a>
<a id='n2658' href='#n2658'>2658</a>
<a id='n2659' href='#n2659'>2659</a>
<a id='n2660' href='#n2660'>2660</a>
<a id='n2661' href='#n2661'>2661</a>
<a id='n2662' href='#n2662'>2662</a>
<a id='n2663' href='#n2663'>2663</a>
<a id='n2664' href='#n2664'>2664</a>
<a id='n2665' href='#n2665'>2665</a>
<a id='n2666' href='#n2666'>2666</a>
<a id='n2667' href='#n2667'>2667</a>
<a id='n2668' href='#n2668'>2668</a>
<a id='n2669' href='#n2669'>2669</a>
<a id='n2670' href='#n2670'>2670</a>
<a id='n2671' href='#n2671'>2671</a>
<a id='n2672' href='#n2672'>2672</a>
<a id='n2673' href='#n2673'>2673</a>
<a id='n2674' href='#n2674'>2674</a>
<a id='n2675' href='#n2675'>2675</a>
<a id='n2676' href='#n2676'>2676</a>
<a id='n2677' href='#n2677'>2677</a>
<a id='n2678' href='#n2678'>2678</a>
<a id='n2679' href='#n2679'>2679</a>
<a id='n2680' href='#n2680'>2680</a>
<a id='n2681' href='#n2681'>2681</a>
<a id='n2682' href='#n2682'>2682</a>
<a id='n2683' href='#n2683'>2683</a>
<a id='n2684' href='#n2684'>2684</a>
<a id='n2685' href='#n2685'>2685</a>
<a id='n2686' href='#n2686'>2686</a>
<a id='n2687' href='#n2687'>2687</a>
<a id='n2688' href='#n2688'>2688</a>
<a id='n2689' href='#n2689'>2689</a>
<a id='n2690' href='#n2690'>2690</a>
<a id='n2691' href='#n2691'>2691</a>
<a id='n2692' href='#n2692'>2692</a>
<a id='n2693' href='#n2693'>2693</a>
<a id='n2694' href='#n2694'>2694</a>
<a id='n2695' href='#n2695'>2695</a>
<a id='n2696' href='#n2696'>2696</a>
<a id='n2697' href='#n2697'>2697</a>
<a id='n2698' href='#n2698'>2698</a>
<a id='n2699' href='#n2699'>2699</a>
<a id='n2700' href='#n2700'>2700</a>
<a id='n2701' href='#n2701'>2701</a>
<a id='n2702' href='#n2702'>2702</a>
<a id='n2703' href='#n2703'>2703</a>
<a id='n2704' href='#n2704'>2704</a>
<a id='n2705' href='#n2705'>2705</a>
<a id='n2706' href='#n2706'>2706</a>
<a id='n2707' href='#n2707'>2707</a>
<a id='n2708' href='#n2708'>2708</a>
<a id='n2709' href='#n2709'>2709</a>
<a id='n2710' href='#n2710'>2710</a>
<a id='n2711' href='#n2711'>2711</a>
<a id='n2712' href='#n2712'>2712</a>
<a id='n2713' href='#n2713'>2713</a>
<a id='n2714' href='#n2714'>2714</a>
<a id='n2715' href='#n2715'>2715</a>
<a id='n2716' href='#n2716'>2716</a>
<a id='n2717' href='#n2717'>2717</a>
<a id='n2718' href='#n2718'>2718</a>
<a id='n2719' href='#n2719'>2719</a>
<a id='n2720' href='#n2720'>2720</a>
<a id='n2721' href='#n2721'>2721</a>
<a id='n2722' href='#n2722'>2722</a>
<a id='n2723' href='#n2723'>2723</a>
<a id='n2724' href='#n2724'>2724</a>
<a id='n2725' href='#n2725'>2725</a>
<a id='n2726' href='#n2726'>2726</a>
<a id='n2727' href='#n2727'>2727</a>
<a id='n2728' href='#n2728'>2728</a>
<a id='n2729' href='#n2729'>2729</a>
<a id='n2730' href='#n2730'>2730</a>
<a id='n2731' href='#n2731'>2731</a>
<a id='n2732' href='#n2732'>2732</a>
<a id='n2733' href='#n2733'>2733</a>
<a id='n2734' href='#n2734'>2734</a>
<a id='n2735' href='#n2735'>2735</a>
<a id='n2736' href='#n2736'>2736</a>
<a id='n2737' href='#n2737'>2737</a>
<a id='n2738' href='#n2738'>2738</a>
<a id='n2739' href='#n2739'>2739</a>
<a id='n2740' href='#n2740'>2740</a>
<a id='n2741' href='#n2741'>2741</a>
<a id='n2742' href='#n2742'>2742</a>
<a id='n2743' href='#n2743'>2743</a>
<a id='n2744' href='#n2744'>2744</a>
<a id='n2745' href='#n2745'>2745</a>
<a id='n2746' href='#n2746'>2746</a>
<a id='n2747' href='#n2747'>2747</a>
<a id='n2748' href='#n2748'>2748</a>
<a id='n2749' href='#n2749'>2749</a>
<a id='n2750' href='#n2750'>2750</a>
<a id='n2751' href='#n2751'>2751</a>
<a id='n2752' href='#n2752'>2752</a>
<a id='n2753' href='#n2753'>2753</a>
<a id='n2754' href='#n2754'>2754</a>
<a id='n2755' href='#n2755'>2755</a>
<a id='n2756' href='#n2756'>2756</a>
<a id='n2757' href='#n2757'>2757</a>
<a id='n2758' href='#n2758'>2758</a>
<a id='n2759' href='#n2759'>2759</a>
<a id='n2760' href='#n2760'>2760</a>
<a id='n2761' href='#n2761'>2761</a>
<a id='n2762' href='#n2762'>2762</a>
<a id='n2763' href='#n2763'>2763</a>
<a id='n2764' href='#n2764'>2764</a>
<a id='n2765' href='#n2765'>2765</a>
<a id='n2766' href='#n2766'>2766</a>
<a id='n2767' href='#n2767'>2767</a>
<a id='n2768' href='#n2768'>2768</a>
<a id='n2769' href='#n2769'>2769</a>
<a id='n2770' href='#n2770'>2770</a>
<a id='n2771' href='#n2771'>2771</a>
<a id='n2772' href='#n2772'>2772</a>
<a id='n2773' href='#n2773'>2773</a>
<a id='n2774' href='#n2774'>2774</a>
<a id='n2775' href='#n2775'>2775</a>
<a id='n2776' href='#n2776'>2776</a>
<a id='n2777' href='#n2777'>2777</a>
<a id='n2778' href='#n2778'>2778</a>
<a id='n2779' href='#n2779'>2779</a>
<a id='n2780' href='#n2780'>2780</a>
<a id='n2781' href='#n2781'>2781</a>
<a id='n2782' href='#n2782'>2782</a>
<a id='n2783' href='#n2783'>2783</a>
<a id='n2784' href='#n2784'>2784</a>
<a id='n2785' href='#n2785'>2785</a>
<a id='n2786' href='#n2786'>2786</a>
<a id='n2787' href='#n2787'>2787</a>
<a id='n2788' href='#n2788'>2788</a>
<a id='n2789' href='#n2789'>2789</a>
<a id='n2790' href='#n2790'>2790</a>
<a id='n2791' href='#n2791'>2791</a>
<a id='n2792' href='#n2792'>2792</a>
<a id='n2793' href='#n2793'>2793</a>
<a id='n2794' href='#n2794'>2794</a>
<a id='n2795' href='#n2795'>2795</a>
<a id='n2796' href='#n2796'>2796</a>
<a id='n2797' href='#n2797'>2797</a>
<a id='n2798' href='#n2798'>2798</a>
<a id='n2799' href='#n2799'>2799</a>
<a id='n2800' href='#n2800'>2800</a>
<a id='n2801' href='#n2801'>2801</a>
<a id='n2802' href='#n2802'>2802</a>
<a id='n2803' href='#n2803'>2803</a>
<a id='n2804' href='#n2804'>2804</a>
<a id='n2805' href='#n2805'>2805</a>
<a id='n2806' href='#n2806'>2806</a>
<a id='n2807' href='#n2807'>2807</a>
<a id='n2808' href='#n2808'>2808</a>
<a id='n2809' href='#n2809'>2809</a>
<a id='n2810' href='#n2810'>2810</a>
<a id='n2811' href='#n2811'>2811</a>
<a id='n2812' href='#n2812'>2812</a>
<a id='n2813' href='#n2813'>2813</a>
<a id='n2814' href='#n2814'>2814</a>
<a id='n2815' href='#n2815'>2815</a>
<a id='n2816' href='#n2816'>2816</a>
<a id='n2817' href='#n2817'>2817</a>
<a id='n2818' href='#n2818'>2818</a>
<a id='n2819' href='#n2819'>2819</a>
<a id='n2820' href='#n2820'>2820</a>
<a id='n2821' href='#n2821'>2821</a>
<a id='n2822' href='#n2822'>2822</a>
<a id='n2823' href='#n2823'>2823</a>
<a id='n2824' href='#n2824'>2824</a>
<a id='n2825' href='#n2825'>2825</a>
<a id='n2826' href='#n2826'>2826</a>
<a id='n2827' href='#n2827'>2827</a>
<a id='n2828' href='#n2828'>2828</a>
<a id='n2829' href='#n2829'>2829</a>
<a id='n2830' href='#n2830'>2830</a>
<a id='n2831' href='#n2831'>2831</a>
<a id='n2832' href='#n2832'>2832</a>
<a id='n2833' href='#n2833'>2833</a>
<a id='n2834' href='#n2834'>2834</a>
<a id='n2835' href='#n2835'>2835</a>
<a id='n2836' href='#n2836'>2836</a>
<a id='n2837' href='#n2837'>2837</a>
<a id='n2838' href='#n2838'>2838</a>
<a id='n2839' href='#n2839'>2839</a>
<a id='n2840' href='#n2840'>2840</a>
<a id='n2841' href='#n2841'>2841</a>
<a id='n2842' href='#n2842'>2842</a>
<a id='n2843' href='#n2843'>2843</a>
<a id='n2844' href='#n2844'>2844</a>
<a id='n2845' href='#n2845'>2845</a>
<a id='n2846' href='#n2846'>2846</a>
<a id='n2847' href='#n2847'>2847</a>
<a id='n2848' href='#n2848'>2848</a>
<a id='n2849' href='#n2849'>2849</a>
<a id='n2850' href='#n2850'>2850</a>
<a id='n2851' href='#n2851'>2851</a>
<a id='n2852' href='#n2852'>2852</a>
<a id='n2853' href='#n2853'>2853</a>
<a id='n2854' href='#n2854'>2854</a>
<a id='n2855' href='#n2855'>2855</a>
<a id='n2856' href='#n2856'>2856</a>
<a id='n2857' href='#n2857'>2857</a>
<a id='n2858' href='#n2858'>2858</a>
<a id='n2859' href='#n2859'>2859</a>
<a id='n2860' href='#n2860'>2860</a>
<a id='n2861' href='#n2861'>2861</a>
<a id='n2862' href='#n2862'>2862</a>
<a id='n2863' href='#n2863'>2863</a>
<a id='n2864' href='#n2864'>2864</a>
<a id='n2865' href='#n2865'>2865</a>
<a id='n2866' href='#n2866'>2866</a>
<a id='n2867' href='#n2867'>2867</a>
<a id='n2868' href='#n2868'>2868</a>
<a id='n2869' href='#n2869'>2869</a>
<a id='n2870' href='#n2870'>2870</a>
<a id='n2871' href='#n2871'>2871</a>
<a id='n2872' href='#n2872'>2872</a>
<a id='n2873' href='#n2873'>2873</a>
<a id='n2874' href='#n2874'>2874</a>
<a id='n2875' href='#n2875'>2875</a>
<a id='n2876' href='#n2876'>2876</a>
<a id='n2877' href='#n2877'>2877</a>
<a id='n2878' href='#n2878'>2878</a>
<a id='n2879' href='#n2879'>2879</a>
<a id='n2880' href='#n2880'>2880</a>
<a id='n2881' href='#n2881'>2881</a>
<a id='n2882' href='#n2882'>2882</a>
<a id='n2883' href='#n2883'>2883</a>
<a id='n2884' href='#n2884'>2884</a>
<a id='n2885' href='#n2885'>2885</a>
<a id='n2886' href='#n2886'>2886</a>
<a id='n2887' href='#n2887'>2887</a>
<a id='n2888' href='#n2888'>2888</a>
<a id='n2889' href='#n2889'>2889</a>
<a id='n2890' href='#n2890'>2890</a>
<a id='n2891' href='#n2891'>2891</a>
<a id='n2892' href='#n2892'>2892</a>
<a id='n2893' href='#n2893'>2893</a>
<a id='n2894' href='#n2894'>2894</a>
<a id='n2895' href='#n2895'>2895</a>
<a id='n2896' href='#n2896'>2896</a>
<a id='n2897' href='#n2897'>2897</a>
<a id='n2898' href='#n2898'>2898</a>
<a id='n2899' href='#n2899'>2899</a>
<a id='n2900' href='#n2900'>2900</a>
<a id='n2901' href='#n2901'>2901</a>
<a id='n2902' href='#n2902'>2902</a>
<a id='n2903' href='#n2903'>2903</a>
<a id='n2904' href='#n2904'>2904</a>
<a id='n2905' href='#n2905'>2905</a>
<a id='n2906' href='#n2906'>2906</a>
<a id='n2907' href='#n2907'>2907</a>
<a id='n2908' href='#n2908'>2908</a>
<a id='n2909' href='#n2909'>2909</a>
<a id='n2910' href='#n2910'>2910</a>
<a id='n2911' href='#n2911'>2911</a>
<a id='n2912' href='#n2912'>2912</a>
<a id='n2913' href='#n2913'>2913</a>
<a id='n2914' href='#n2914'>2914</a>
<a id='n2915' href='#n2915'>2915</a>
<a id='n2916' href='#n2916'>2916</a>
<a id='n2917' href='#n2917'>2917</a>
<a id='n2918' href='#n2918'>2918</a>
<a id='n2919' href='#n2919'>2919</a>
<a id='n2920' href='#n2920'>2920</a>
<a id='n2921' href='#n2921'>2921</a>
<a id='n2922' href='#n2922'>2922</a>
<a id='n2923' href='#n2923'>2923</a>
<a id='n2924' href='#n2924'>2924</a>
<a id='n2925' href='#n2925'>2925</a>
<a id='n2926' href='#n2926'>2926</a>
<a id='n2927' href='#n2927'>2927</a>
<a id='n2928' href='#n2928'>2928</a>
<a id='n2929' href='#n2929'>2929</a>
<a id='n2930' href='#n2930'>2930</a>
<a id='n2931' href='#n2931'>2931</a>
<a id='n2932' href='#n2932'>2932</a>
<a id='n2933' href='#n2933'>2933</a>
<a id='n2934' href='#n2934'>2934</a>
<a id='n2935' href='#n2935'>2935</a>
<a id='n2936' href='#n2936'>2936</a>
<a id='n2937' href='#n2937'>2937</a>
<a id='n2938' href='#n2938'>2938</a>
<a id='n2939' href='#n2939'>2939</a>
<a id='n2940' href='#n2940'>2940</a>
<a id='n2941' href='#n2941'>2941</a>
<a id='n2942' href='#n2942'>2942</a>
<a id='n2943' href='#n2943'>2943</a>
<a id='n2944' href='#n2944'>2944</a>
<a id='n2945' href='#n2945'>2945</a>
<a id='n2946' href='#n2946'>2946</a>
<a id='n2947' href='#n2947'>2947</a>
<a id='n2948' href='#n2948'>2948</a>
<a id='n2949' href='#n2949'>2949</a>
<a id='n2950' href='#n2950'>2950</a>
<a id='n2951' href='#n2951'>2951</a>
<a id='n2952' href='#n2952'>2952</a>
<a id='n2953' href='#n2953'>2953</a>
<a id='n2954' href='#n2954'>2954</a>
<a id='n2955' href='#n2955'>2955</a>
<a id='n2956' href='#n2956'>2956</a>
<a id='n2957' href='#n2957'>2957</a>
<a id='n2958' href='#n2958'>2958</a>
<a id='n2959' href='#n2959'>2959</a>
<a id='n2960' href='#n2960'>2960</a>
<a id='n2961' href='#n2961'>2961</a>
<a id='n2962' href='#n2962'>2962</a>
<a id='n2963' href='#n2963'>2963</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/*</span>
<span class="hl com"> * tclOO.c --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	This file contains the object-system core (NB: not Tcl_Obj, but ::oo)</span>
<span class="hl com"> *</span>
<span class="hl com"> * Copyright (c) 2005-2011 by Donal K. Fellows</span>
<span class="hl com"> *</span>
<span class="hl com"> * See the file &quot;license.terms&quot; for information on usage and redistribution of</span>
<span class="hl com"> * this file, and for a DISCLAIMER OF ALL WARRANTIES.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#ifdef HAVE_CONFIG_H</span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;config.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;tclInt.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;tclOOInt.h&quot;</span><span class="hl ppc"></span>

<span class="hl com">/*</span>
<span class="hl com"> * Commands in oo::define.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const struct</span> <span class="hl opt">{</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">;</span>
    Tcl_ObjCmdProc <span class="hl opt">*</span>objProc<span class="hl opt">;</span>
    <span class="hl kwb">int</span> flag<span class="hl opt">;</span>
<span class="hl opt">}</span> defineCmds<span class="hl opt">[] = {</span>
    <span class="hl opt">{</span><span class="hl str">&quot;constructor&quot;</span><span class="hl opt">,</span> TclOODefineConstructorObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;deletemethod&quot;</span><span class="hl opt">,</span> TclOODefineDeleteMethodObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;destructor&quot;</span><span class="hl opt">,</span> TclOODefineDestructorObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;export&quot;</span><span class="hl opt">,</span> TclOODefineExportObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;forward&quot;</span><span class="hl opt">,</span> TclOODefineForwardObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;method&quot;</span><span class="hl opt">,</span> TclOODefineMethodObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;renamemethod&quot;</span><span class="hl opt">,</span> TclOODefineRenameMethodObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;self&quot;</span><span class="hl opt">,</span> TclOODefineSelfObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;unexport&quot;</span><span class="hl opt">,</span> TclOODefineUnexportObjCmd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">},</span>
    <span class="hl opt">{</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">}</span>
<span class="hl opt">},</span> objdefCmds<span class="hl opt">[] = {</span>
    <span class="hl opt">{</span><span class="hl str">&quot;class&quot;</span><span class="hl opt">,</span> TclOODefineClassObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;deletemethod&quot;</span><span class="hl opt">,</span> TclOODefineDeleteMethodObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;export&quot;</span><span class="hl opt">,</span> TclOODefineExportObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;forward&quot;</span><span class="hl opt">,</span> TclOODefineForwardObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;method&quot;</span><span class="hl opt">,</span> TclOODefineMethodObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;renamemethod&quot;</span><span class="hl opt">,</span> TclOODefineRenameMethodObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;unexport&quot;</span><span class="hl opt">,</span> TclOODefineUnexportObjCmd<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">},</span>
    <span class="hl opt">{</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">}</span>
<span class="hl opt">};</span>

<span class="hl com">/*</span>
<span class="hl com"> * What sort of size of things we like to allocate.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define ALLOC_CHUNK 8</span>

<span class="hl com">/*</span>
<span class="hl com"> * Function declarations for things defined in this file.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> Class <span class="hl opt">*</span>		<span class="hl kwd">AllocClass</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> Object <span class="hl opt">*</span>useThisObj<span class="hl opt">);</span>
<span class="hl kwb">static</span> Object <span class="hl opt">*</span>		<span class="hl kwd">AllocObject</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>nameStr<span class="hl opt">,</span>
			    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nsNameStr<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">CloneClassMethod</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> Class <span class="hl opt">*</span>clsPtr<span class="hl opt">,</span>
			    Method <span class="hl opt">*</span>mPtr<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">,</span>
			    Method <span class="hl opt">**</span>newMPtrPtr<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">CloneObjectMethod</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> Object <span class="hl opt">*</span>oPtr<span class="hl opt">,</span>
			    Method <span class="hl opt">*</span>mPtr<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">DeletedDefineNamespace</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">DeletedObjdefNamespace</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">DeletedHelpersNamespace</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">FinalizeAlloc</span><span class="hl opt">(</span>ClientData data<span class="hl opt">[],</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> result<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">FinalizeNext</span><span class="hl opt">(</span>ClientData data<span class="hl opt">[],</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> result<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">FinalizeObjectCall</span><span class="hl opt">(</span>ClientData data<span class="hl opt">[],</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> result<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">InitFoundation</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">KillFoundation</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">MyDeleted</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">ObjectNamespaceDeleted</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">ObjectRenamedTrace</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>oldName<span class="hl opt">,</span>
			    <span class="hl kwb">const char</span> <span class="hl opt">*</span>newName<span class="hl opt">,</span> <span class="hl kwb">int</span> flags<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">ReleaseClassContents</span><span class="hl opt">(</span>Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>Object <span class="hl opt">*</span>oPtr<span class="hl opt">);</span>
<span class="hl kwb">static void</span>		<span class="hl kwd">SquelchedNsFirst</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">);</span>

<span class="hl kwb">static int</span>		<span class="hl kwd">PublicObjectCmd</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
			    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">PublicNRObjectCmd</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
			    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">PrivateObjectCmd</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
			    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">);</span>
<span class="hl kwb">static int</span>		<span class="hl kwd">PrivateNRObjectCmd</span><span class="hl opt">(</span>ClientData clientData<span class="hl opt">,</span>
			    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span> <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
			    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">);</span>

<span class="hl com">/*</span>
<span class="hl com"> * Methods in the oo::object and oo::class classes. First, we define a helper</span>
<span class="hl com"> * macro that makes building the method type declaration structure a lot</span>
<span class="hl com"> * easier. No point in making life harder than it has to be!</span>
<span class="hl com"> *</span>
<span class="hl com"> * Note that the core methods don't need clone or free proc callbacks.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define DCM(name,visibility,proc) \</span>
<span class="hl ppc">    {name,visibility,\</span>
<span class="hl ppc">	{TCL_OO_METHOD_VERSION_CURRENT,</span><span class="hl pps">&quot;core method: &quot;</span><span class="hl ppc">#name,proc,NULL,NULL}}</span>

<span class="hl kwb">static const</span> DeclaredClassMethod objMethods<span class="hl opt">[] = {</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;destroy&quot;</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span>	TclOO_Object_Destroy<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;eval&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>	TclOO_Object_Eval<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;unknown&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>	TclOO_Object_Unknown<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;variable&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>	TclOO_Object_LinkVar<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;varname&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>	TclOO_Object_VarName<span class="hl opt">),</span>
    <span class="hl opt">{</span>NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, {</span><span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">}}</span>
<span class="hl opt">},</span> clsMethods<span class="hl opt">[] = {</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;create&quot;</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span>	TclOO_Class_Create<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;new&quot;</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span>	TclOO_Class_New<span class="hl opt">),</span>
    <span class="hl kwd">DCM</span><span class="hl opt">(</span><span class="hl str">&quot;createWithNamespace&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> TclOO_Class_CreateNs<span class="hl opt">),</span>
    <span class="hl opt">{</span>NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, {</span><span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">}}</span>
<span class="hl opt">};</span>

<span class="hl com">/*</span>
<span class="hl com"> * Scripted parts of TclOO. First, the master script (cannot be outside this</span>
<span class="hl com"> * file).</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const char</span> <span class="hl opt">*</span>initScript <span class="hl opt">=</span>
<span class="hl str">&quot;package ifneeded TclOO &quot;</span> TCLOO_PATCHLEVEL <span class="hl str">&quot; {# Already present, OK?};&quot;</span>
<span class="hl str">&quot;namespace eval ::oo { variable version &quot;</span> TCLOO_VERSION <span class="hl str">&quot; };&quot;</span>
<span class="hl str">&quot;namespace eval ::oo { variable patchlevel &quot;</span> TCLOO_PATCHLEVEL <span class="hl str">&quot; };&quot;</span><span class="hl opt">;</span>
<span class="hl com">/* &quot;tcl_findLibrary tcloo $oo::version $oo::version&quot; */</span>
<span class="hl com">/* &quot; tcloo.tcl OO_LIBRARY oo::library;&quot;; */</span>

<span class="hl com">/*</span>
<span class="hl com"> * The body of the constructor for oo::class.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const char</span> <span class="hl opt">*</span>classConstructorBody <span class="hl opt">=</span>
<span class="hl str">&quot;set script [list ::oo::define [self] $definitionScript];&quot;</span>
<span class="hl str">&quot;lassign [::oo::UpCatch $script] msg opts;&quot;</span>
<span class="hl str">&quot;if {[dict get $opts -code] == 1} {&quot;</span>
<span class="hl str">&quot;    dict set opts -errorline 0xDeadBeef&quot;</span>
<span class="hl str">&quot;};&quot;</span>
<span class="hl str">&quot;return -options $opts $msg;&quot;</span><span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * The scripted part of the definitions of slots.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const char</span> <span class="hl opt">*</span>slotScript <span class="hl opt">=</span>
<span class="hl str">&quot;::oo::define ::oo::Slot {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method Get {} {error unimplemented}</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method Set list {error unimplemented}</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method -set args {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        uplevel 1 [list [namespace which my] Set $args]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    }</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method -append args {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        uplevel 1 [list [namespace which my] Set [list&quot;</span>
<span class="hl str">&quot;                {*}[uplevel 1 [list [namespace which my] Get]] {*}$args]]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    }</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method -clear {} {uplevel 1 [list [namespace which my] Set {}]}</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    forward --default-operation my -append</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    method unknown {args} {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        set def --default-operation</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        if {[llength $args] == 0} {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;            return [uplevel 1 [list [namespace which my] $def]]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        } elseif {![string match -* [lindex $args 0]]} {</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;            return [uplevel 1 [list [namespace which my] $def {*}$args]]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        }</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;        next {*}$args</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    }</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    export -set -append -clear</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;    unexport unknown destroy</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;}</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;::oo::objdefine ::oo::define::superclass forward --default-operation my -set</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;::oo::objdefine ::oo::define::mixin forward --default-operation my -set</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;::oo::objdefine ::oo::objdefine::mixin forward --default-operation my -set</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * The body of the &lt;cloned&gt; method of oo::object.</span>
<span class="hl com"> */</span>

<span class="hl kwb">static const char</span> <span class="hl opt">*</span>clonedBody <span class="hl opt">=</span>
<span class="hl str">&quot;foreach p [info procs [info object namespace $originObject]::*] {&quot;</span>
<span class="hl str">&quot;    set args [info args $p];&quot;</span>
<span class="hl str">&quot;    set idx -1;&quot;</span>
<span class="hl str">&quot;    foreach a $args {&quot;</span>
<span class="hl str">&quot;        lset args [incr idx] &quot;</span>
<span class="hl str">&quot;            [if {[info default $p $a d]} {list $a $d} {list $a}]&quot;</span>
<span class="hl str">&quot;    };&quot;</span>
<span class="hl str">&quot;    set b [info body $p];&quot;</span>
<span class="hl str">&quot;    set p [namespace tail $p];&quot;</span>
<span class="hl str">&quot;    proc $p $args $b;&quot;</span>
<span class="hl str">&quot;};&quot;</span>
<span class="hl str">&quot;foreach v [info vars [info object namespace $originObject]::*] {&quot;</span>
<span class="hl str">&quot;    upvar 0 $v vOrigin;&quot;</span>
<span class="hl str">&quot;    namespace upvar [namespace current] [namespace tail $v] vNew;&quot;</span>
<span class="hl str">&quot;    if {[info exists vOrigin]} {&quot;</span>
<span class="hl str">&quot;        if {[array exists vOrigin]} {&quot;</span>
<span class="hl str">&quot;            array set vNew [array get vOrigin];&quot;</span>
<span class="hl str">&quot;        } else {&quot;</span>
<span class="hl str">&quot;            set vNew $vOrigin;&quot;</span>
<span class="hl str">&quot;        }&quot;</span>
<span class="hl str">&quot;    }&quot;</span>
<span class="hl str">&quot;}&quot;</span><span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * The actual definition of the variable holding the TclOO stub table.</span>
<span class="hl com"> */</span>

MODULE_SCOPE <span class="hl kwb">const</span> TclOOStubs tclOOStubs<span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * Convenience macro for getting the foundation from an interpreter.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define GetFoundation(interp) \</span>
<span class="hl ppc">	((Foundation *)((Interp *)(interp))-&gt;objectFoundation)</span>

<span class="hl com">/*</span>
<span class="hl com"> * Macros to make inspecting into the guts of an object cleaner.</span>
<span class="hl com"> *</span>
<span class="hl com"> * The ocPtr parameter (only in these macros) is assumed to work fine with</span>
<span class="hl com"> * either an oPtr or a classPtr. Note that the roots oo::object and oo::class</span>
<span class="hl com"> * have _both_ their object and class flags tagged with ROOT_OBJECT and</span>
<span class="hl com"> * ROOT_CLASS respectively.</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define Deleted(oPtr)		(((Object *)(oPtr))-&gt;command == NULL)</span>
<span class="hl ppc">#define IsRootObject(ocPtr)	((ocPtr)-&gt;flags &amp; ROOT_OBJECT)</span>
<span class="hl ppc">#define IsRootClass(ocPtr)	((ocPtr)-&gt;flags &amp; ROOT_CLASS)</span>
<span class="hl ppc">#define IsRoot(ocPtr)		((ocPtr)-&gt;flags &amp; (ROOT_OBJECT|ROOT_CLASS))</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOInit --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Called to initialise the OO system within an interpreter.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Result:</span>
<span class="hl com"> *	TCL_OK if the setup succeeded. Currently assumed to always work.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Side effects:</span>
<span class="hl com"> *	Creates namespaces, commands, several classes and a number of</span>
<span class="hl com"> *	callbacks. Upon return, the OO system is ready for use.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclOOInit</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">)</span>		<span class="hl com">/* The interpreter to install into. */</span>
<span class="hl opt">{</span>
    <span class="hl com">/*</span>
<span class="hl com">     * Build the core of the OO system.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">InitFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Run our initialization script and, if that works, declare the package</span>
<span class="hl com">     * to be fully provided.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Tcl_Eval</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> initScript<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_PkgProvideEx</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TclOO&quot;</span><span class="hl opt">,</span> TCLOO_VERSION<span class="hl opt">,</span>
	    <span class="hl opt">(</span>ClientData<span class="hl opt">) &amp;</span>tclOOStubs<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOGetFoundation --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Get a reference to the OO core class system.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Foundation <span class="hl opt">*</span>
<span class="hl kwd">TclOOGetFoundation</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * InitFoundation --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Set up the core of the OO core class system. This is a structure</span>
<span class="hl com"> *	holding references to the magical bits that need to be known about in</span>
<span class="hl com"> *	other places, plus the oo::object and oo::class classes.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">InitFoundation</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">static</span> Tcl_ThreadDataKey tsdKey<span class="hl opt">;</span>
    ThreadLocalData <span class="hl opt">*</span>tsdPtr <span class="hl opt">=</span>
	    <span class="hl kwd">Tcl_GetThreadData</span><span class="hl opt">(&amp;</span>tsdKey<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>ThreadLocalData<span class="hl opt">));</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Foundation<span class="hl opt">));</span>
    Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">, *</span>argsPtr<span class="hl opt">, *</span>bodyPtr<span class="hl opt">;</span>
    Tcl_DString buffer<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Initialize the structure that holds the OO system core. This is</span>
<span class="hl com">     * attached to the interpreter via an assocData entry; not very efficient,</span>
<span class="hl com">     * but the best we can do without hacking the core more.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">memset</span><span class="hl opt">(</span>fPtr<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Foundation<span class="hl opt">));</span>
    <span class="hl opt">((</span>Interp <span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>objectFoundation <span class="hl opt">=</span> fPtr<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>interp <span class="hl opt">=</span> interp<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>ooNs <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo&quot;</span><span class="hl opt">,</span> fPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_Export</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>ooNs<span class="hl opt">,</span> <span class="hl str">&quot;[a-z]*&quot;</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>defineNs <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::define&quot;</span><span class="hl opt">,</span> fPtr<span class="hl opt">,</span>
	    DeletedDefineNamespace<span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>objdefNs <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::objdefine&quot;</span><span class="hl opt">,</span> fPtr<span class="hl opt">,</span>
	    DeletedObjdefNamespace<span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>helpersNs <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::Helpers&quot;</span><span class="hl opt">,</span> fPtr<span class="hl opt">,</span>
	    DeletedHelpersNamespace<span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>epoch <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>tsdPtr <span class="hl opt">=</span> tsdPtr<span class="hl opt">;</span>
    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>unknownMethodNameObj<span class="hl opt">,</span> <span class="hl str">&quot;unknown&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>constructorName<span class="hl opt">,</span> <span class="hl str">&quot;&lt;constructor&gt;&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>destructorName<span class="hl opt">,</span> <span class="hl str">&quot;&lt;destructor&gt;&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">,</span> <span class="hl str">&quot;&lt;cloned&gt;&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>unknownMethodNameObj<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>constructorName<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>destructorName<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_NRCreateCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::UpCatch&quot;</span><span class="hl opt">,</span> TclOOUpcatchCmd<span class="hl opt">,</span>
	    TclOONRUpcatch<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::UnknownDefinition&quot;</span><span class="hl opt">,</span>
	    TclOOUnknownDefinition<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>namePtr<span class="hl opt">,</span> <span class="hl str">&quot;::oo::UnknownDefinition&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Tcl_SetNamespaceUnknownHandler</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>defineNs<span class="hl opt">,</span> namePtr<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_SetNamespaceUnknownHandler</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objdefNs<span class="hl opt">,</span> namePtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the subcommands in the oo::define and oo::objdefine spaces.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">Tcl_DStringInit</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">);</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span> <span class="hl opt">;</span> defineCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>name <span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> <span class="hl str">&quot;::oo::define::&quot;</span><span class="hl opt">,</span> <span class="hl num">14</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> defineCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>name<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl kwd">Tcl_DStringValue</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">),</span>
		defineCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>objProc<span class="hl opt">,</span> <span class="hl kwd">INT2PTR</span><span class="hl opt">(</span>defineCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>flag<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringFree</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span> <span class="hl opt">;</span> objdefCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>name <span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> <span class="hl str">&quot;::oo::objdefine::&quot;</span><span class="hl opt">,</span> <span class="hl num">17</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> objdefCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>name<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl kwd">Tcl_DStringValue</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">),</span>
		objdefCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>objProc<span class="hl opt">,</span> <span class="hl kwd">INT2PTR</span><span class="hl opt">(</span>objdefCmds<span class="hl opt">[</span>i<span class="hl opt">].</span>flag<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringFree</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">Tcl_CallWhenDeleted</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> KillFoundation<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the objects at the core of the object system. These need to be</span>
<span class="hl com">     * spliced manually.</span>
<span class="hl com">     */</span>

    fPtr<span class="hl opt">-&gt;</span>objectCls <span class="hl opt">=</span> <span class="hl kwd">AllocClass</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
	    <span class="hl kwd">AllocObject</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::object&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">));</span>
    fPtr<span class="hl opt">-&gt;</span>classCls <span class="hl opt">=</span> <span class="hl kwd">AllocClass</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
	    <span class="hl kwd">AllocObject</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::class&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">));</span>
    fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> ROOT_OBJECT<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> ROOT_OBJECT<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> ROOT_CLASS<span class="hl opt">;</span>
    fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> ROOT_CLASS<span class="hl opt">;</span>
    <span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">);</span>
    <span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Basic method declarations for the core classes.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span> <span class="hl opt">;</span> objMethods<span class="hl opt">[</span>i<span class="hl opt">].</span>name <span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwd">TclOONewBasicMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">, &amp;</span>objMethods<span class="hl opt">[</span>i<span class="hl opt">]);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span> <span class="hl opt">;</span> clsMethods<span class="hl opt">[</span>i<span class="hl opt">].</span>name <span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwd">TclOONewBasicMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">, &amp;</span>clsMethods<span class="hl opt">[</span>i<span class="hl opt">]);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the default &lt;cloned&gt; method implementation, used when 'oo::copy'</span>
<span class="hl com">     * is called to finish the copying of one object to another.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>argsPtr<span class="hl opt">,</span> <span class="hl str">&quot;originObject&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>argsPtr<span class="hl opt">);</span>
    bodyPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_NewStringObj</span><span class="hl opt">(</span>clonedBody<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwd">TclOONewProcMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">,</span> argsPtr<span class="hl opt">,</span>
	    bodyPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>argsPtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Finish setting up the class of classes by marking the 'new' method as</span>
<span class="hl com">     * private; classes, unlike general objects, must have explicit names. We</span>
<span class="hl com">     * also need to create the constructor for classes.</span>
<span class="hl com">     *</span>
<span class="hl com">     * The 0xDeadBeef is a special signal to the errorInfo logger that is used</span>
<span class="hl com">     * by constructors that stops it from generating extra error information</span>
<span class="hl com">     * that is confusing.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>namePtr<span class="hl opt">,</span> <span class="hl str">&quot;new&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Tcl_NewInstanceMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Object<span class="hl opt">)</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">,</span>
	    namePtr <span class="hl com">/* keeps ref */</span><span class="hl opt">,</span> <span class="hl num">0</span> <span class="hl com">/* ==private */</span><span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

    <span class="hl kwd">TclNewLiteralStringObj</span><span class="hl opt">(</span>argsPtr<span class="hl opt">,</span> <span class="hl str">&quot;{definitionScript {}}&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>argsPtr<span class="hl opt">);</span>
    bodyPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_NewStringObj</span><span class="hl opt">(</span>classConstructorBody<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
    fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>constructorPtr <span class="hl opt">=</span> <span class="hl kwd">TclOONewProcMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
	    fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">,</span> argsPtr<span class="hl opt">,</span> bodyPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>argsPtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create non-object commands and plug ourselves into the Tcl [info]</span>
<span class="hl com">     * ensemble.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::Helpers::next&quot;</span><span class="hl opt">,</span> TclOONextObjCmd<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::Helpers::nextto&quot;</span><span class="hl opt">,</span> TclOONextToObjCmd<span class="hl opt">,</span>
	    NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::Helpers::self&quot;</span><span class="hl opt">,</span> TclOOSelfObjCmd<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::define&quot;</span><span class="hl opt">,</span> TclOODefineObjCmd<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::objdefine&quot;</span><span class="hl opt">,</span> TclOOObjDefObjCmd<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;::oo::copy&quot;</span><span class="hl opt">,</span> TclOOCopyObjectCmd<span class="hl opt">,</span> NULL<span class="hl opt">,</span>NULL<span class="hl opt">);</span>
    <span class="hl kwd">TclOOInitInfo</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Now make the class of slots.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">TclOODefineSlots</span><span class="hl opt">(</span>fPtr<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_Eval</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> slotScript<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * DeletedDefineNamespace, DeletedObjdefNamespace, DeletedHelpersNamespace --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Simple helpers used to clear fields of the foundation when they no</span>
<span class="hl com"> *	longer hold useful information.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">DeletedDefineNamespace</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>

    fPtr<span class="hl opt">-&gt;</span>defineNs <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">DeletedObjdefNamespace</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>

    fPtr<span class="hl opt">-&gt;</span>objdefNs <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">DeletedHelpersNamespace</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>

    fPtr<span class="hl opt">-&gt;</span>helpersNs <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * KillFoundation --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Delete those parts of the OO core that are not deleted automatically</span>
<span class="hl com"> *	when the objects and classes themselves are destroyed.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">KillFoundation</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>	<span class="hl com">/* Pointer to the OO system foundation</span>
<span class="hl com">				 * structure. */</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">)</span>		<span class="hl com">/* The interpreter containing the OO system</span>
<span class="hl com">				 * foundation. */</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>

    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>unknownMethodNameObj<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>constructorName<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>destructorName<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">);</span>
    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>fPtr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * AllocObject --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Allocate an object of basic type. Does not splice the object into its</span>
<span class="hl com"> *	class's instance list.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> Object <span class="hl opt">*</span>
<span class="hl kwd">AllocObject</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter within which to create the</span>
<span class="hl com">				 * object. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nameStr<span class="hl opt">,</span>	<span class="hl com">/* The name of the object to create, or NULL</span>
<span class="hl com">				 * if the OO system should pick the object</span>
<span class="hl com">				 * name itself (equal to the namespace</span>
<span class="hl com">				 * name). */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nsNameStr<span class="hl opt">)</span>	<span class="hl com">/* The name of the namespace to create, or</span>
<span class="hl com">				 * NULL if the OO system should pick a unique</span>
<span class="hl com">				 * name itself. If this is non-NULL but names</span>
<span class="hl com">				 * a namespace that already exists, the effect</span>
<span class="hl com">				 * will be the same as if this was NULL. */</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">;</span>
    Command <span class="hl opt">*</span>cmdPtr<span class="hl opt">;</span>
    CommandTrace <span class="hl opt">*</span>tracePtr<span class="hl opt">;</span>
    <span class="hl kwb">int</span> creationEpoch<span class="hl opt">,</span> ignored<span class="hl opt">;</span>

    oPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Object<span class="hl opt">));</span>
    <span class="hl kwd">memset</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Object<span class="hl opt">));</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Every object has a namespace; make one. Note that this also normally</span>
<span class="hl com">     * computes the creation epoch value for the object, a sequence number</span>
<span class="hl com">     * that is unique to the object (and which allows us to manage method</span>
<span class="hl com">     * caching without comparing pointers).</span>
<span class="hl com">     *</span>
<span class="hl com">     * When creating a namespace, we first check to see if the caller</span>
<span class="hl com">     * specified the name for the namespace. If not, we generate namespace</span>
<span class="hl com">     * names using the epoch until such time as a new namespace is actually</span>
<span class="hl com">     * created.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>nsNameStr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	oPtr<span class="hl opt">-&gt;</span>namespacePtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nsNameStr<span class="hl opt">,</span> oPtr<span class="hl opt">,</span>
		ObjectNamespaceDeleted<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>namespacePtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    creationEpoch <span class="hl opt">= ++</span>fPtr<span class="hl opt">-&gt;</span>tsdPtr<span class="hl opt">-&gt;</span>nsCount<span class="hl opt">;</span>
	    <span class="hl kwa">goto</span> configNamespace<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_ResetResult</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">while</span> <span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">) {</span>
	<span class="hl kwb">char</span> objName<span class="hl opt">[</span><span class="hl num">10</span> <span class="hl opt">+</span> TCL_INTEGER_SPACE<span class="hl opt">];</span>

	<span class="hl kwd">sprintf</span><span class="hl opt">(</span>objName<span class="hl opt">,</span> <span class="hl str">&quot;::oo::Obj%d&quot;</span><span class="hl opt">, ++</span>fPtr<span class="hl opt">-&gt;</span>tsdPtr<span class="hl opt">-&gt;</span>nsCount<span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>namespacePtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> objName<span class="hl opt">,</span> oPtr<span class="hl opt">,</span>
		ObjectNamespaceDeleted<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>namespacePtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    creationEpoch <span class="hl opt">=</span> fPtr<span class="hl opt">-&gt;</span>tsdPtr<span class="hl opt">-&gt;</span>nsCount<span class="hl opt">;</span>
	    <span class="hl kwa">break</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Could not make that namespace, so we make another. But first we</span>
<span class="hl com">	 * have to get rid of the error message from Tcl_CreateNamespace,</span>
<span class="hl com">	 * since that's something that should not be exposed to the user.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">Tcl_ResetResult</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Make the namespace know about the helper commands. This grants access</span>
<span class="hl com">     * to the [self] and [next] commands.</span>
<span class="hl com">     */</span>

  configNamespace<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>helpersNs <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">TclSetNsPath</span><span class="hl opt">((</span>Namespace <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">, &amp;</span>fPtr<span class="hl opt">-&gt;</span>helpersNs<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">TclOOSetupVariableResolver</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Suppress use of compiled versions of the commands in this object's</span>
<span class="hl com">     * namespace and its children; causes wrong behaviour without expensive</span>
<span class="hl com">     * recompilation. [Bug 2037727]</span>
<span class="hl com">     */</span>

    <span class="hl opt">((</span>Namespace <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">)-&gt;</span>flags <span class="hl opt">|=</span> NS_SUPPRESS_COMPILATION<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Set up a callback to get notification of the deletion of a namespace</span>
<span class="hl com">     * when enough of the namespace still remains to execute commands and</span>
<span class="hl com">     * access variables in it. [Bug 2950259]</span>
<span class="hl com">     */</span>

    <span class="hl opt">((</span>Namespace <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">)-&gt;</span>earlyDeleteProc <span class="hl opt">=</span> SquelchedNsFirst<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Fill in the rest of the non-zero/NULL parts of the structure.</span>
<span class="hl com">     */</span>

    oPtr<span class="hl opt">-&gt;</span>fPtr <span class="hl opt">=</span> fPtr<span class="hl opt">;</span>
    oPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">;</span>
    oPtr<span class="hl opt">-&gt;</span>creationEpoch <span class="hl opt">=</span> creationEpoch<span class="hl opt">;</span>
    oPtr<span class="hl opt">-&gt;</span>refCount <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> USE_CLASS_CACHE<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Finally, create the object commands and initialize the trace on the</span>
<span class="hl com">     * public command (so that the object structures are deleted when the</span>
<span class="hl com">     * command is deleted).</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span>nameStr<span class="hl opt">) {</span>
	oPtr<span class="hl opt">-&gt;</span>command <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
		oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">-&gt;</span>fullName<span class="hl opt">,</span> PublicObjectCmd<span class="hl opt">,</span> oPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>nameStr<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> <span class="hl str">':'</span> <span class="hl opt">&amp;&amp;</span> nameStr<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">] ==</span> <span class="hl str">':'</span><span class="hl opt">) {</span>
	oPtr<span class="hl opt">-&gt;</span>command <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nameStr<span class="hl opt">,</span>
		PublicObjectCmd<span class="hl opt">,</span> oPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	Tcl_DString buffer<span class="hl opt">;</span>

	<span class="hl kwd">Tcl_DStringInit</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span>
		<span class="hl kwd">Tcl_GetCurrentNamespace</span><span class="hl opt">(</span>interp<span class="hl opt">)-&gt;</span>fullName<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> <span class="hl str">&quot;::&quot;</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringAppend</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">,</span> nameStr<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>command <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateObjCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
		<span class="hl kwd">Tcl_DStringValue</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">),</span> PublicObjectCmd<span class="hl opt">,</span> oPtr<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DStringFree</span><span class="hl opt">(&amp;</span>buffer<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Add the NRE command and trace directly. While this breaks a number of</span>
<span class="hl com">     * abstractions, it is faster and we're inside Tcl here so we're allowed.</span>
<span class="hl com">     */</span>

    cmdPtr <span class="hl opt">= (</span>Command <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>nreProc <span class="hl opt">=</span> PublicNRObjectCmd<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>tracePtr <span class="hl opt">=</span> tracePtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>CommandTrace<span class="hl opt">));</span>
    tracePtr<span class="hl opt">-&gt;</span>traceProc <span class="hl opt">=</span> ObjectRenamedTrace<span class="hl opt">;</span>
    tracePtr<span class="hl opt">-&gt;</span>clientData <span class="hl opt">=</span> oPtr<span class="hl opt">;</span>
    tracePtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> TCL_TRACE_RENAME<span class="hl opt">|</span>TCL_TRACE_DELETE<span class="hl opt">;</span>
    tracePtr<span class="hl opt">-&gt;</span>nextPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    tracePtr<span class="hl opt">-&gt;</span>refCount <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Access the namespace command table directly when creating &quot;my&quot; to avoid</span>
<span class="hl com">     * a bottleneck in string manipulation. Another abstraction-buster.</span>
<span class="hl com">     */</span>

    cmdPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Command<span class="hl opt">));</span>
    <span class="hl kwd">memset</span><span class="hl opt">(</span>cmdPtr<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Command<span class="hl opt">));</span>
    cmdPtr<span class="hl opt">-&gt;</span>nsPtr <span class="hl opt">= (</span>Namespace <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateHashEntry</span><span class="hl opt">(&amp;</span>cmdPtr<span class="hl opt">-&gt;</span>nsPtr<span class="hl opt">-&gt;</span>cmdTable<span class="hl opt">,</span> <span class="hl str">&quot;my&quot;</span><span class="hl opt">,</span>
	    <span class="hl opt">&amp;</span>ignored<span class="hl opt">);</span>
    cmdPtr<span class="hl opt">-&gt;</span>refCount <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>objProc <span class="hl opt">=</span> PrivateObjectCmd<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>deleteProc <span class="hl opt">=</span> MyDeleted<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>objClientData <span class="hl opt">=</span> cmdPtr<span class="hl opt">-&gt;</span>deleteData <span class="hl opt">=</span> oPtr<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>proc <span class="hl opt">=</span> TclInvokeObjectCommand<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>clientData <span class="hl opt">=</span> cmdPtr<span class="hl opt">;</span>
    cmdPtr<span class="hl opt">-&gt;</span>nreProc <span class="hl opt">=</span> PrivateNRObjectCmd<span class="hl opt">;</span>
    <span class="hl kwd">Tcl_SetHashValue</span><span class="hl opt">(</span>cmdPtr<span class="hl opt">-&gt;</span>hPtr<span class="hl opt">,</span> cmdPtr<span class="hl opt">);</span>
    oPtr<span class="hl opt">-&gt;</span>myCommand <span class="hl opt">= (</span>Tcl_Command<span class="hl opt">)</span> cmdPtr<span class="hl opt">;</span>

    <span class="hl kwa">return</span> oPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * MyDeleted --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	This callback is triggered when the object's [my] command is deleted</span>
<span class="hl com"> *	by any mechanism. It just marks the object as not having a [my]</span>
<span class="hl com"> *	command, and so prevents cleanup of that when the object itself is</span>
<span class="hl com"> *	deleted.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">MyDeleted</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>	<span class="hl com">/* Reference to the object whose [my] has been</span>
<span class="hl com">				 * squelched. */</span>
<span class="hl opt">{</span>
    <span class="hl kwc">register</span> Object <span class="hl opt">*</span>oPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>

    oPtr<span class="hl opt">-&gt;</span>myCommand <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * SquelchedNsFirst --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	This callback is triggered when the object's namespace is deleted by</span>
<span class="hl com"> *	any mechanism. It deletes the object's public command if it has not</span>
<span class="hl com"> *	already been deleted, so ensuring that destructors get run at an</span>
<span class="hl com"> *	appropriate time. [Bug 2950259]</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">SquelchedNsFirst</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">-&gt;</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * ObjectRenamedTrace --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	This callback is triggered when the object is deleted by any</span>
<span class="hl com"> *	mechanism. It runs the destructors and arranges for the actual cleanup</span>
<span class="hl com"> *	of the object's namespace, which in turn triggers cleansing of the</span>
<span class="hl com"> *	object data structures.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">ObjectRenamedTrace</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>	<span class="hl com">/* The object being deleted. */</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* The interpreter containing the object. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>oldName<span class="hl opt">,</span>	<span class="hl com">/* What the object was (last) called. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>newName<span class="hl opt">,</span>	<span class="hl com">/* Always NULL. */</span>
    <span class="hl kwb">int</span> flags<span class="hl opt">)</span>			<span class="hl com">/* Why was the object deleted? */</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If this is a rename and not a delete of the object, we just flush the</span>
<span class="hl com">     * cache of the object name.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>flags <span class="hl opt">&amp;</span> TCL_TRACE_RENAME<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">);</span>
	    oPtr<span class="hl opt">-&gt;</span>cachedNameObj <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Oh dear, the object really is being deleted. Handle this by running the</span>
<span class="hl com">     * destructors and deleting the object's namespace, which in turn causes</span>
<span class="hl com">     * the real object structures to be deleted.</span>
<span class="hl com">     *</span>
<span class="hl com">     * Note that it is possible for the namespace to be deleted before the</span>
<span class="hl com">     * command. Because of that case, we must take care here to mark the</span>
<span class="hl com">     * command as being deleted so that if we return here we don't run into</span>
<span class="hl com">     * reentrancy problems.</span>
<span class="hl com">     *</span>
<span class="hl com">     * We also do not run destructors on the core class objects when the</span>
<span class="hl com">     * interpreter is being deleted; their incestuous nature causes problems</span>
<span class="hl com">     * in that case when the destructor is partially deleted before the uses</span>
<span class="hl com">     * of it have gone. [Bug 2949397]</span>
<span class="hl com">     */</span>

    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    oPtr<span class="hl opt">-&gt;</span>command <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!(</span>oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> DESTRUCTOR_CALLED<span class="hl opt">) &amp;&amp; !</span><span class="hl kwd">Tcl_InterpDeleted</span><span class="hl opt">(</span>interp<span class="hl opt">)) {</span>
	CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">=</span>
		<span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> NULL<span class="hl opt">,</span> DESTRUCTOR<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwb">int</span> result<span class="hl opt">;</span>
	Tcl_InterpState state<span class="hl opt">;</span>

	oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> DESTRUCTOR_CALLED<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> DESTRUCTOR<span class="hl opt">;</span>
	    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	    state <span class="hl opt">=</span> <span class="hl kwd">Tcl_SaveInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TCL_OK<span class="hl opt">);</span>
	    result <span class="hl opt">=</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TclOOInvokeContext<span class="hl opt">,</span>
		    contextPtr<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_BackgroundError</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwd">Tcl_RestoreInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> state<span class="hl opt">);</span>
	    <span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * OK, the destructor's been run. Time to splat the class data (if any)</span>
<span class="hl com">     * and nuke the namespace (which triggers the final crushing of the object</span>
<span class="hl com">     * structure itself).</span>
<span class="hl com">     *</span>
<span class="hl com">     * The class of objects needs some special care; if it is deleted (and</span>
<span class="hl com">     * we're not killing the whole interpreter) we force the delete of the</span>
<span class="hl com">     * class of classes now as well. Due to the incestuous nature of those two</span>
<span class="hl com">     * classes, if one goes the other must too and yet the tangle can</span>
<span class="hl com">     * sometimes not go away automatically; we force it here. [Bug 2962664]</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Tcl_InterpDeleted</span><span class="hl opt">(</span>interp<span class="hl opt">) &amp;&amp;</span> <span class="hl kwd">IsRootObject</span><span class="hl opt">(</span>oPtr<span class="hl opt">)</span>
	    <span class="hl opt">&amp;&amp; !</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">AddRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">);</span>
	<span class="hl kwd">ReleaseClassContents</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * The namespace is only deleted if it hasn't already been deleted. [Bug</span>
<span class="hl com">     * 2950259]</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(((</span>Namespace <span class="hl opt">*)</span> oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">)-&gt;</span>earlyDeleteProc <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DeleteNamespace</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">) {</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">);</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * ReleaseClassContents --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Tear down the special class data structure, including deleting all</span>
<span class="hl com"> *	dependent classes and objects.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">ReleaseClassContents</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* The interpreter containing the class. */</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">)</span>		<span class="hl com">/* The object representing the class. */</span>
<span class="hl opt">{</span>
    FOREACH_HASH_DECLS<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>clsPtr <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">, *</span>mixinSubclassPtr<span class="hl opt">, *</span>subclassPtr<span class="hl opt">;</span>
    Object <span class="hl opt">*</span>instancePtr<span class="hl opt">;</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Sanity check!</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IsRootClass</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">Tcl_Panic</span><span class="hl opt">(</span><span class="hl str">&quot;deleting class structure for non-deleted %s&quot;</span><span class="hl opt">,</span>
		    <span class="hl str">&quot;::oo::class&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span><span class="hl kwd">IsRootObject</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">Tcl_Panic</span><span class="hl opt">(</span><span class="hl str">&quot;deleting class structure for non-deleted %s&quot;</span><span class="hl opt">,</span>
		    <span class="hl str">&quot;::oo::object&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    <span class="hl kwd">Tcl_Panic</span><span class="hl opt">(</span><span class="hl str">&quot;deleting class structure for non-deleted %s&quot;</span><span class="hl opt">,</span>
		    <span class="hl str">&quot;general object&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Lock a number of dependent objects until we've stopped putting our</span>
<span class="hl com">     * fingers in them.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>mixinSubclassPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">);</span>
	    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>subclassPtr <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp; !</span><span class="hl kwd">IsRoot</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">);</span>
	    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">IsRootClass</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>instancePtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>instancePtr <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp; !</span><span class="hl kwd">IsRoot</span><span class="hl opt">(</span>instancePtr<span class="hl opt">)) {</span>
		<span class="hl kwd">AddRef</span><span class="hl opt">(</span>instancePtr<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch classes that this class has been mixed into.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>mixinSubclassPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwa">continue</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
		    mixinSubclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>mixinSubclassPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch subclasses of this class.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>subclassPtr <span class="hl opt">==</span> NULL <span class="hl opt">||</span> <span class="hl kwd">IsRoot</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">)) {</span>
	    <span class="hl kwa">continue</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> subclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">);</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>subclassPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch instances of this class (includes objects we're mixed into).</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">IsRootClass</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>instancePtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>instancePtr <span class="hl opt">==</span> NULL <span class="hl opt">||</span> <span class="hl kwd">IsRoot</span><span class="hl opt">(</span>instancePtr<span class="hl opt">)) {</span>
		<span class="hl kwa">continue</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>instancePtr<span class="hl opt">)) {</span>
		<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> instancePtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>instancePtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Special: We delete these after everything else.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IsRootClass</span><span class="hl opt">(</span>oPtr<span class="hl opt">) &amp;&amp; !</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch method implementation chain caches.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>constructorChainPtr<span class="hl opt">) {</span>
	<span class="hl kwd">TclOODeleteChain</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>constructorChainPtr<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>constructorChainPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>destructorChainPtr<span class="hl opt">) {</span>
	<span class="hl kwd">TclOODeleteChain</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>destructorChainPtr<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>destructorChainPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>classChainCache<span class="hl opt">) {</span>
	CallChain <span class="hl opt">*</span>callPtr<span class="hl opt">;</span>

	<span class="hl kwd">FOREACH_HASH_VALUE</span><span class="hl opt">(</span>callPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>classChainCache<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOODeleteChain</span><span class="hl opt">(</span>callPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>classChainCache<span class="hl opt">);</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>classChainCache<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>classChainCache <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch our filter list.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>num<span class="hl opt">) {</span>
	Tcl_Obj <span class="hl opt">*</span>filterObj<span class="hl opt">;</span>

	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>filterObj<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>filterObj<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>list<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Squelch our metadata.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Tcl_ObjectMetadataType <span class="hl opt">*</span>metadataTypePtr<span class="hl opt">;</span>
	ClientData value<span class="hl opt">;</span>

	<span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>metadataTypePtr<span class="hl opt">,</span> value<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">) {</span>
	    metadataTypePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span>value<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * ObjectNamespaceDeleted --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Callback when the object's namespace is deleted. Used to clean up the</span>
<span class="hl com"> *	data structures associated with the object. The complicated bit is</span>
<span class="hl com"> *	that this can sometimes happen before the object's command is deleted</span>
<span class="hl com"> *	(interpreter teardown is complex!)</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">ObjectNamespaceDeleted</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">)</span>	<span class="hl com">/* Pointer to the class whose namespace is</span>
<span class="hl com">				 * being deleted. */</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">=</span> clientData<span class="hl opt">;</span>
    FOREACH_HASH_DECLS<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>clsPtr <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">, *</span>mixinPtr<span class="hl opt">;</span>
    Method <span class="hl opt">*</span>mPtr<span class="hl opt">;</span>
    Tcl_Obj <span class="hl opt">*</span>filterObj<span class="hl opt">, *</span>variableObj<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Instruct everyone to no longer use any allocated fields of the object.</span>
<span class="hl com">     * Also delete the commands that refer to the object at this point (if</span>
<span class="hl com">     * they still exist) because otherwise their references to the object</span>
<span class="hl com">     * point into freed memory, allowing crashes.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">-&gt;</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>myCommand<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">-&gt;</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>myCommand<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Splice the object out of its context. After this, we must *not* call</span>
<span class="hl com">     * methods on the object.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">IsRootObject</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">TclOORemoveFromInstances</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>selfCls<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	<span class="hl kwd">TclOORemoveFromInstances</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>list<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>filterObj<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>filterObj<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>list<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">) {</span>
	<span class="hl kwd">FOREACH_HASH_VALUE</span><span class="hl opt">(</span>mPtr<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOODelMethodRef</span><span class="hl opt">(</span>mPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">);</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>variableObj<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>variableObj<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">.</span>list<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>chainCache<span class="hl opt">) {</span>
	<span class="hl kwd">TclOODeleteChainCache</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>chainCache<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>cachedNameObj <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Tcl_ObjectMetadataType <span class="hl opt">*</span>metadataTypePtr<span class="hl opt">;</span>
	ClientData value<span class="hl opt">;</span>

	<span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>metadataTypePtr<span class="hl opt">,</span> value<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">) {</span>
	    metadataTypePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span>value<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	<span class="hl kwd">ckfree</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Class <span class="hl opt">*</span>superPtr<span class="hl opt">;</span>
	Tcl_ObjectMetadataType <span class="hl opt">*</span>metadataTypePtr<span class="hl opt">;</span>
	ClientData value<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>metadataTypePtr<span class="hl opt">,</span> value<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">) {</span>
		metadataTypePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span>value<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>filterObj<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>filterObj<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
		<span class="hl kwd">TclOORemoveFromMixinSubs</span><span class="hl opt">(</span>clsPtr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>superPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
		<span class="hl kwd">TclOORemoveFromSubclasses</span><span class="hl opt">(</span>clsPtr<span class="hl opt">,</span> superPtr<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">);</span>
	    clsPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">FOREACH_HASH_VALUE</span><span class="hl opt">(</span>mPtr<span class="hl opt">, &amp;</span>clsPtr<span class="hl opt">-&gt;</span>classMethods<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOODelMethodRef</span><span class="hl opt">(</span>mPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_DeleteHashTable</span><span class="hl opt">(&amp;</span>clsPtr<span class="hl opt">-&gt;</span>classMethods<span class="hl opt">);</span>
	<span class="hl kwd">TclOODelMethodRef</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>constructorPtr<span class="hl opt">);</span>
	<span class="hl kwd">TclOODelMethodRef</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>destructorPtr<span class="hl opt">);</span>

	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>variableObj<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>variableObj<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">.</span>list<span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>clsPtr<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Delete the object structure itself.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOORemoveFromInstances --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to remove an object from the list of instances within</span>
<span class="hl com"> *	a class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOORemoveFromInstances</span><span class="hl opt">(</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">,</span>		<span class="hl com">/* The instance to remove. */</span>
    Class <span class="hl opt">*</span>clsPtr<span class="hl opt">)</span>		<span class="hl com">/* The class (possibly) containing the</span>
<span class="hl com">				 * reference to the instance. */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    Object <span class="hl opt">*</span>instPtr<span class="hl opt">;</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>instPtr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr <span class="hl opt">==</span> instPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">goto</span> removeInstance<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span><span class="hl opt">;</span>

  removeInstance<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num<span class="hl opt">--;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i <span class="hl opt">&lt;</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num<span class="hl opt">) {</span>
	    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span>
		    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">[</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num<span class="hl opt">];</span>
	<span class="hl opt">}</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">[</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOAddToInstances --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to add an object to the list of instances within a</span>
<span class="hl com"> *	class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">,</span>		<span class="hl com">/* The instance to add. */</span>
    Class <span class="hl opt">*</span>clsPtr<span class="hl opt">)</span>		<span class="hl com">/* The class to add the instance to. It is</span>
<span class="hl com">				 * assumed that the class is not already</span>
<span class="hl com">				 * present as an instance in the class. */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num <span class="hl opt">&gt;=</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>size<span class="hl opt">) {</span>
	clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>size <span class="hl opt">+=</span> ALLOC_CHUNK<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>size <span class="hl opt">==</span> ALLOC_CHUNK<span class="hl opt">) {</span>
	    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Object <span class="hl opt">*) *</span> ALLOC_CHUNK<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckrealloc</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">,</span>
		    <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Object <span class="hl opt">*) *</span> clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>size<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>list<span class="hl opt">[</span>clsPtr<span class="hl opt">-&gt;</span>instances<span class="hl opt">.</span>num<span class="hl opt">++] =</span> oPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOORemoveFromSubclasses --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to remove a class from the list of subclasses within</span>
<span class="hl com"> *	another class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOORemoveFromSubclasses</span><span class="hl opt">(</span>
    Class <span class="hl opt">*</span>subPtr<span class="hl opt">,</span>		<span class="hl com">/* The subclass to remove. */</span>
    Class <span class="hl opt">*</span>superPtr<span class="hl opt">)</span>		<span class="hl com">/* The superclass to (possibly) remove the</span>
<span class="hl com">				 * subclass reference from. */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>subclsPtr<span class="hl opt">;</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>subclsPtr<span class="hl opt">,</span> superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>subPtr <span class="hl opt">==</span> subclsPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">goto</span> removeSubclass<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span><span class="hl opt">;</span>

  removeSubclass<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num<span class="hl opt">--;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i <span class="hl opt">&lt;</span> superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num<span class="hl opt">) {</span>
	    superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span>
		    superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num<span class="hl opt">];</span>
	<span class="hl opt">}</span>
	superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOAddToSubclasses --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to add a class to the list of subclasses within</span>
<span class="hl com"> *	another class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOOAddToSubclasses</span><span class="hl opt">(</span>
    Class <span class="hl opt">*</span>subPtr<span class="hl opt">,</span>		<span class="hl com">/* The subclass to add. */</span>
    Class <span class="hl opt">*</span>superPtr<span class="hl opt">)</span>		<span class="hl com">/* The superclass to add the subclass to. It</span>
<span class="hl com">				 * is assumed that the class is not already</span>
<span class="hl com">				 * present as a subclass in the superclass. */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num <span class="hl opt">&gt;=</span> superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>size<span class="hl opt">) {</span>
	superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>size <span class="hl opt">+=</span> ALLOC_CHUNK<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>size <span class="hl opt">==</span> ALLOC_CHUNK<span class="hl opt">) {</span>
	    superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class<span class="hl opt">*) *</span> ALLOC_CHUNK<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckrealloc</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">,</span>
		    <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>size<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>subclasses<span class="hl opt">.</span>num<span class="hl opt">++] =</span> subPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOORemoveFromMixinSubs --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to remove a class from the list of mixinSubs within</span>
<span class="hl com"> *	another class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOORemoveFromMixinSubs</span><span class="hl opt">(</span>
    Class <span class="hl opt">*</span>subPtr<span class="hl opt">,</span>		<span class="hl com">/* The subclass to remove. */</span>
    Class <span class="hl opt">*</span>superPtr<span class="hl opt">)</span>		<span class="hl com">/* The superclass to (possibly) remove the</span>
<span class="hl com">				 * subclass reference from. */</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>subclsPtr<span class="hl opt">;</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>subclsPtr<span class="hl opt">,</span> superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>subPtr <span class="hl opt">==</span> subclsPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">goto</span> removeSubclass<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span><span class="hl opt">;</span>

  removeSubclass<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num<span class="hl opt">--;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>i <span class="hl opt">&lt;</span> superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num<span class="hl opt">) {</span>
	    superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">[</span>i<span class="hl opt">] =</span>
		    superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num<span class="hl opt">];</span>
	<span class="hl opt">}</span>
	superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num<span class="hl opt">] =</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOAddToMixinSubs --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to add a class to the list of mixinSubs within</span>
<span class="hl com"> *	another class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">TclOOAddToMixinSubs</span><span class="hl opt">(</span>
    Class <span class="hl opt">*</span>subPtr<span class="hl opt">,</span>		<span class="hl com">/* The subclass to add. */</span>
    Class <span class="hl opt">*</span>superPtr<span class="hl opt">)</span>		<span class="hl com">/* The superclass to add the subclass to. It</span>
<span class="hl com">				 * is assumed that the class is not already</span>
<span class="hl com">				 * present as a subclass in the superclass. */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">)) {</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num <span class="hl opt">&gt;=</span> superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>size<span class="hl opt">) {</span>
	superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>size <span class="hl opt">+=</span> ALLOC_CHUNK<span class="hl opt">;</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>size <span class="hl opt">==</span> ALLOC_CHUNK<span class="hl opt">) {</span>
	    superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> ALLOC_CHUNK<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckrealloc</span><span class="hl opt">(</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">,</span>
		    <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>size<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>list<span class="hl opt">[</span>superPtr<span class="hl opt">-&gt;</span>mixinSubs<span class="hl opt">.</span>num<span class="hl opt">++] =</span> subPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * AllocClass --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Allocate a basic class. Does not splice the class object into its</span>
<span class="hl com"> *	class's instance list.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static</span> Class <span class="hl opt">*</span>
<span class="hl kwd">AllocClass</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter within which to allocate the</span>
<span class="hl com">				 * class. */</span>
    Object <span class="hl opt">*</span>useThisObj<span class="hl opt">)</span>		<span class="hl com">/* Object that is to act as the class</span>
<span class="hl com">				 * representation, or NULL if a new object</span>
<span class="hl com">				 * (with automatic name) is to be used. */</span>
<span class="hl opt">{</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    Class <span class="hl opt">*</span>clsPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class<span class="hl opt">));</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Make an object if we haven't been given one.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">memset</span><span class="hl opt">(</span>clsPtr<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>useThisObj <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	clsPtr<span class="hl opt">-&gt;</span>thisPtr <span class="hl opt">=</span> <span class="hl kwd">AllocObject</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	clsPtr<span class="hl opt">-&gt;</span>thisPtr <span class="hl opt">=</span> useThisObj<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Configure the namespace path for the class's object.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>helpersNs <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Tcl_Namespace <span class="hl opt">*</span>path<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">];</span>

	path<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> fPtr<span class="hl opt">-&gt;</span>helpersNs<span class="hl opt">;</span>
	path<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">] =</span> fPtr<span class="hl opt">-&gt;</span>ooNs<span class="hl opt">;</span>
	<span class="hl kwd">TclSetNsPath</span><span class="hl opt">((</span>Namespace <span class="hl opt">*)</span> clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">,</span> path<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl kwd">TclSetNsPath</span><span class="hl opt">((</span>Namespace <span class="hl opt">*)</span> clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>namespacePtr<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span>
		<span class="hl opt">&amp;</span>fPtr<span class="hl opt">-&gt;</span>ooNs<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Class objects inherit from the class of classes unless they inherit</span>
<span class="hl com">     * from some subclass of it. Enforce this right now.</span>
<span class="hl com">     */</span>

    clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Classes are subclasses of oo::object, i.e. the objects they create are</span>
<span class="hl com">     * objects.</span>
<span class="hl com">     */</span>

    clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*));</span>
    clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Finish connecting the class structure to the object structure.</span>
<span class="hl com">     */</span>

    clsPtr<span class="hl opt">-&gt;</span>thisPtr<span class="hl opt">-&gt;</span>classPtr <span class="hl opt">=</span> clsPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * That's the complicated bit. Now fill in the rest of the non-zero/NULL</span>
<span class="hl com">     * fields.</span>
<span class="hl com">     */</span>

    clsPtr<span class="hl opt">-&gt;</span>refCount <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwd">Tcl_InitObjHashTable</span><span class="hl opt">(&amp;</span>clsPtr<span class="hl opt">-&gt;</span>classMethods<span class="hl opt">);</span>
    <span class="hl kwa">return</span> clsPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Tcl_NewObjectInstance --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Allocate a new instance of an object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Tcl_Object
<span class="hl kwd">Tcl_NewObjectInstance</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter context. */</span>
    Tcl_Class cls<span class="hl opt">,</span>		<span class="hl com">/* Class to create an instance of. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nameStr<span class="hl opt">,</span>	<span class="hl com">/* Name of object to create, or NULL to ask</span>
<span class="hl com">				 * the code to pick its own unique name. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nsNameStr<span class="hl opt">,</span>	<span class="hl com">/* Name of namespace to create inside object,</span>
<span class="hl com">				 * or NULL to ask the code to pick its own</span>
<span class="hl com">				 * unique name. */</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>			<span class="hl com">/* Number of arguments. Negative value means</span>
<span class="hl com">				 * do not call constructor. */</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">,</span>	<span class="hl com">/* Argument list. */</span>
    <span class="hl kwb">int</span> skip<span class="hl opt">)</span>			<span class="hl com">/* Number of arguments to _not_ pass to the</span>
<span class="hl com">				 * constructor. */</span>
<span class="hl opt">{</span>
    <span class="hl kwc">register</span> Class <span class="hl opt">*</span>classPtr <span class="hl opt">= (</span>Class <span class="hl opt">*)</span> cls<span class="hl opt">;</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Check if we're going to create an object over an existing command;</span>
<span class="hl com">     * that's not allowed.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>nameStr <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">Tcl_FindCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nameStr<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    TCL_NAMESPACE_ONLY<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;can't create object</span> <span class="hl esc">\&quot;</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nameStr<span class="hl opt">,</span>
		<span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">: command already exists with that name&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OVERWRITE_OBJECT&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the object.</span>
<span class="hl com">     */</span>

    oPtr <span class="hl opt">=</span> <span class="hl kwd">AllocObject</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nameStr<span class="hl opt">,</span> nsNameStr<span class="hl opt">);</span>
    oPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> classPtr<span class="hl opt">;</span>
    <span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> classPtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Check to see if we're really creating a class. If so, allocate the</span>
<span class="hl com">     * class structure as well.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">TclOOIsReachable</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">,</span> classPtr<span class="hl opt">)) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Is a class, so attach a class structure. Note that the AllocClass</span>
<span class="hl com">	 * function splices the structure into the object, so we don't have</span>
<span class="hl com">	 * to. Once that's done, we need to repatch the object to have the</span>
<span class="hl com">	 * right class since AllocClass interferes with that.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">AllocClass</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> classPtr<span class="hl opt">;</span>
	<span class="hl kwd">TclOOAddToSubclasses</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Run constructors, except when objc &lt; 0 (a special flag case used for</span>
<span class="hl com">     * object cloning only).</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>objc <span class="hl opt">&gt;=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">=</span>
		<span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> NULL<span class="hl opt">,</span> CONSTRUCTOR<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwb">int</span> result<span class="hl opt">;</span>
	    Tcl_InterpState state<span class="hl opt">;</span>

	    state <span class="hl opt">=</span> <span class="hl kwd">Tcl_SaveInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TCL_OK<span class="hl opt">);</span>
	    contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> CONSTRUCTOR<span class="hl opt">;</span>
	    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> skip<span class="hl opt">;</span>

	    <span class="hl com">/*</span>
<span class="hl com">	     * Adjust the ensmble tracking record if necessary. [Bug 3514761]</span>
<span class="hl com">	     */</span>

	    <span class="hl kwa">if</span> <span class="hl opt">(((</span>Interp<span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>sourceObjs<span class="hl opt">) {</span>
		<span class="hl opt">((</span>Interp<span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>numInsertedObjs <span class="hl opt">+=</span> skip<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
		<span class="hl opt">((</span>Interp<span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>numRemovedObjs <span class="hl opt">+=</span> skip<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    result <span class="hl opt">=</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TclOOInvokeContext<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span>
		    objc<span class="hl opt">,</span> objv<span class="hl opt">);</span>

	    <span class="hl com">/*</span>
<span class="hl com">	     * It's an error if the object was whacked in the constructor.</span>
<span class="hl com">	     * Force this if it isn't already an error (don't want to lose</span>
<span class="hl com">	     * errors by accident...) [Bug 2903011]</span>
<span class="hl com">	     */</span>

	    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_ERROR <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">Deleted</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
		<span class="hl kwd">Tcl_SetResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;object deleted in constructor&quot;</span><span class="hl opt">,</span>
			TCL_STATIC<span class="hl opt">);</span>
		<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;STILLBORN&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
		result <span class="hl opt">=</span> TCL_ERROR<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">);</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_DiscardInterpState</span><span class="hl opt">(</span>state<span class="hl opt">);</span>

		<span class="hl com">/*</span>
<span class="hl com">		 * Take care to not delete a deleted object; that would be</span>
<span class="hl com">		 * bad. [Bug 2903011]</span>
<span class="hl com">		 */</span>

		<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
		    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		<span class="hl opt">}</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwd">Tcl_RestoreInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> state<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclNRNewObjectInstance</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter context. */</span>
    Tcl_Class cls<span class="hl opt">,</span>		<span class="hl com">/* Class to create an instance of. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nameStr<span class="hl opt">,</span>	<span class="hl com">/* Name of object to create, or NULL to ask</span>
<span class="hl com">				 * the code to pick its own unique name. */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>nsNameStr<span class="hl opt">,</span>	<span class="hl com">/* Name of namespace to create inside object,</span>
<span class="hl com">				 * or NULL to ask the code to pick its own</span>
<span class="hl com">				 * unique name. */</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>			<span class="hl com">/* Number of arguments. Negative value means</span>
<span class="hl com">				 * do not call constructor. */</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">,</span>	<span class="hl com">/* Argument list. */</span>
    <span class="hl kwb">int</span> skip<span class="hl opt">,</span>			<span class="hl com">/* Number of arguments to _not_ pass to the</span>
<span class="hl com">				 * constructor. */</span>
    Tcl_Object <span class="hl opt">*</span>objectPtr<span class="hl opt">)</span>	<span class="hl com">/* Place to write the object reference upon</span>
<span class="hl com">				 * successful allocation. */</span>
<span class="hl opt">{</span>
    <span class="hl kwc">register</span> Class <span class="hl opt">*</span>classPtr <span class="hl opt">= (</span>Class <span class="hl opt">*)</span> cls<span class="hl opt">;</span>
    Foundation <span class="hl opt">*</span>fPtr <span class="hl opt">=</span> <span class="hl kwd">GetFoundation</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    CallContext <span class="hl opt">*</span>contextPtr<span class="hl opt">;</span>
    Tcl_InterpState state<span class="hl opt">;</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Check if we're going to create an object over an existing command;</span>
<span class="hl com">     * that's not allowed.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>nameStr <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">Tcl_FindCommand</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nameStr<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
	    TCL_NAMESPACE_ONLY<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;can't create object</span> <span class="hl esc">\&quot;</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nameStr<span class="hl opt">,</span>
		<span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">: command already exists with that name&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OVERWRITE_OBJECT&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the object.</span>
<span class="hl com">     */</span>

    oPtr <span class="hl opt">=</span> <span class="hl kwd">AllocObject</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> nameStr<span class="hl opt">,</span> nsNameStr<span class="hl opt">);</span>
    oPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> classPtr<span class="hl opt">;</span>
    <span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> classPtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Check to see if we're really creating a class. If so, allocate the</span>
<span class="hl com">     * class structure as well.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">TclOOIsReachable</span><span class="hl opt">(</span>fPtr<span class="hl opt">-&gt;</span>classCls<span class="hl opt">,</span> classPtr<span class="hl opt">)) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Is a class, so attach a class structure. Note that the AllocClass</span>
<span class="hl com">	 * function splices the structure into the object, so we don't have</span>
<span class="hl com">	 * to. Once that's done, we need to repatch the object to have the</span>
<span class="hl com">	 * right class since AllocClass interferes with that.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">AllocClass</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">);</span>
	oPtr<span class="hl opt">-&gt;</span>selfCls <span class="hl opt">=</span> classPtr<span class="hl opt">;</span>
	<span class="hl kwd">TclOOAddToSubclasses</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">,</span> fPtr<span class="hl opt">-&gt;</span>objectCls<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Run constructors, except when objc &lt; 0 (a special flag case used for</span>
<span class="hl com">     * object cloning only). If there aren't any constructors, we do nothing.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>objc <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	<span class="hl opt">*</span>objectPtr <span class="hl opt">= (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">;</span>
	<span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    contextPtr <span class="hl opt">=</span> <span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> NULL<span class="hl opt">,</span> CONSTRUCTOR<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl opt">*</span>objectPtr <span class="hl opt">= (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">;</span>
	<span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    state <span class="hl opt">=</span> <span class="hl kwd">Tcl_SaveInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TCL_OK<span class="hl opt">);</span>
    contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">|=</span> CONSTRUCTOR<span class="hl opt">;</span>
    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> skip<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Adjust the ensmble tracking record if necessary. [Bug 3514761]</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(((</span>Interp <span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>sourceObjs<span class="hl opt">) {</span>
	<span class="hl opt">((</span>Interp <span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>numInsertedObjs <span class="hl opt">+=</span> skip <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">;</span>
	<span class="hl opt">((</span>Interp <span class="hl opt">*)</span> interp<span class="hl opt">)-&gt;</span>ensembleRewrite<span class="hl opt">.</span>numRemovedObjs <span class="hl opt">+=</span> skip <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Fire off the constructors non-recursively.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">AddRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
    <span class="hl kwd">TclNRAddCallback</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> FinalizeAlloc<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span> oPtr<span class="hl opt">,</span> state<span class="hl opt">,</span>
	    objectPtr<span class="hl opt">);</span>
    <span class="hl kwd">TclPushTailcallPoint</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl kwd">TclOOInvokeContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">FinalizeAlloc</span><span class="hl opt">(</span>
    ClientData data<span class="hl opt">[],</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> result<span class="hl opt">)</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">=</span> data<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">];</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">=</span> data<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">];</span>
    Tcl_InterpState state <span class="hl opt">=</span> data<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">];</span>
    Tcl_Object <span class="hl opt">*</span>objectPtr <span class="hl opt">=</span> data<span class="hl opt">[</span><span class="hl num">3</span><span class="hl opt">];</span>

    <span class="hl com">/*</span>
<span class="hl com">     * It's an error if the object was whacked in the constructor. Force this</span>
<span class="hl com">     * if it isn't already an error (don't want to lose errors by accident...)</span>
<span class="hl com">     * [Bug 2903011]</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_ERROR <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">Deleted</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_SetResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;object deleted in constructor&quot;</span><span class="hl opt">,</span> TCL_STATIC<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;STILLBORN&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	result <span class="hl opt">=</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_OK<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_DiscardInterpState</span><span class="hl opt">(</span>state<span class="hl opt">);</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Take care to not delete a deleted object; that would be bad. [Bug</span>
<span class="hl com">	 * 2903011]</span>
<span class="hl com">	 */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">Deleted</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">DelRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Tcl_RestoreInterpState</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> state<span class="hl opt">);</span>
    <span class="hl opt">*</span>objectPtr <span class="hl opt">= (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">;</span>
    <span class="hl kwd">DelRef</span><span class="hl opt">(</span>oPtr<span class="hl opt">);</span>
    <span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Tcl_CopyObjectInstance --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Creates a copy of an object. Does not copy the backing namespace,</span>
<span class="hl com"> *	since the correct way to do that (e.g., shallow/deep) depends on the</span>
<span class="hl com"> *	object/class's own policies.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Tcl_Object
<span class="hl kwd">Tcl_CopyObjectInstance</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Tcl_Object sourceObject<span class="hl opt">,</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>targetName<span class="hl opt">,</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>targetNamespaceName<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">= (</span>Object <span class="hl opt">*)</span> sourceObject<span class="hl opt">, *</span>o2Ptr<span class="hl opt">;</span>
    FOREACH_HASH_DECLS<span class="hl opt">;</span>
    Method <span class="hl opt">*</span>mPtr<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>mixinPtr<span class="hl opt">;</span>
    CallContext <span class="hl opt">*</span>contextPtr<span class="hl opt">;</span>
    Tcl_Obj <span class="hl opt">*</span>keyPtr<span class="hl opt">, *</span>filterObj<span class="hl opt">, *</span>variableObj<span class="hl opt">, *</span>args<span class="hl opt">[</span><span class="hl num">3</span><span class="hl opt">];</span>
    <span class="hl kwb">int</span> i<span class="hl opt">,</span> result<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Sanity check.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IsRootClass</span><span class="hl opt">(</span>oPtr<span class="hl opt">)) {</span>
	<span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;may not clone the class of classes&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;CLONING_CLASS&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Build the instance. Note that this does not run any constructors.</span>
<span class="hl com">     */</span>

    o2Ptr <span class="hl opt">= (</span>Object <span class="hl opt">*)</span> <span class="hl kwd">Tcl_NewObjectInstance</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
	    <span class="hl opt">(</span>Tcl_Class<span class="hl opt">)</span> oPtr<span class="hl opt">-&gt;</span>selfCls<span class="hl opt">,</span> targetName<span class="hl opt">,</span> targetNamespaceName<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">,</span>
	    NULL<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>o2Ptr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object-local methods to the new object.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">) {</span>
	<span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>keyPtr<span class="hl opt">,</span> mPtr<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>methodsPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">CloneObjectMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">,</span> mPtr<span class="hl opt">,</span> keyPtr<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object's mixin references to the new object.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>mixinPtr <span class="hl opt">!=</span> o2Ptr<span class="hl opt">-&gt;</span>selfCls<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOORemoveFromInstances</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">,</span> Class <span class="hl opt">*);</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>mixinPtr <span class="hl opt">!=</span> o2Ptr<span class="hl opt">-&gt;</span>selfCls<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOOAddToInstances</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object's filter list to the new object.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">-&gt;</span>filters<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*);</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>filterObj<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>filters<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>filterObj<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object's variable resolution list to the new object.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">-&gt;</span>variables<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*);</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>variableObj<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>variables<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>variableObj<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object's flags to the new object, clearing those that must be</span>
<span class="hl com">     * kept object-local. The duplicate is never deleted at this point, nor is</span>
<span class="hl com">     * it the root of the object system or in the midst of processing a filter</span>
<span class="hl com">     * call.</span>
<span class="hl com">     */</span>

    o2Ptr<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp; ~(</span>
	    OBJECT_DELETED <span class="hl opt">|</span> ROOT_OBJECT <span class="hl opt">|</span> ROOT_CLASS <span class="hl opt">|</span> FILTER_HANDLING<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the object's metadata.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Tcl_ObjectMetadataType <span class="hl opt">*</span>metadataTypePtr<span class="hl opt">;</span>
	ClientData value<span class="hl opt">,</span> duplicate<span class="hl opt">;</span>

	<span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>metadataTypePtr<span class="hl opt">,</span> value<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>metadataTypePtr<span class="hl opt">-&gt;</span>cloneProc <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
		duplicate <span class="hl opt">=</span> value<span class="hl opt">;</span>
	    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>metadataTypePtr<span class="hl opt">-&gt;</span><span class="hl kwd">cloneProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> value<span class="hl opt">,</span>
			<span class="hl opt">&amp;</span>duplicate<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
		    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		    <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
		<span class="hl opt">}</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>duplicate <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_ObjectSetMetadata</span><span class="hl opt">((</span>Tcl_Object<span class="hl opt">)</span> o2Ptr<span class="hl opt">,</span> metadataTypePtr<span class="hl opt">,</span>
			duplicate<span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Copy the class, if present. Note that if there is a class present in</span>
<span class="hl com">     * the source object, there must also be one in the copy.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>classPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	Class <span class="hl opt">*</span>clsPtr <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">;</span>
	Class <span class="hl opt">*</span>cls2Ptr <span class="hl opt">=</span> o2Ptr<span class="hl opt">-&gt;</span>classPtr<span class="hl opt">;</span>
	Class <span class="hl opt">*</span>superPtr<span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Copy the class flags across.</span>
<span class="hl com">	 */</span>

	cls2Ptr<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> clsPtr<span class="hl opt">-&gt;</span>flags<span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Ensure that the new class's superclass structure is the same as the</span>
<span class="hl com">	 * old class's.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>superPtr<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOORemoveFromSubclasses</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">,</span> superPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num<span class="hl opt">) {</span>
	    cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list <span class="hl opt">=</span> <span class="hl kwd">ckrealloc</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">,</span>
		    <span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list <span class="hl opt">=</span>
		    <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">memcpy</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">,</span>
		<span class="hl kwa">sizeof</span><span class="hl opt">(</span>Class <span class="hl opt">*) *</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num<span class="hl opt">);</span>
	cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num <span class="hl opt">=</span> clsPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num<span class="hl opt">;</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>superPtr<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOOAddToSubclasses</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">,</span> superPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Duplicate the source class's filters.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>filters<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>filters<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*);</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>filterObj<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>filters<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>filterObj<span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Copy the source class's variable resolution list.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>variables<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>variables<span class="hl opt">,</span> Tcl_Obj <span class="hl opt">*);</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>variableObj<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>variables<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>variableObj<span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Duplicate the source class's mixins (which cannot be circular</span>
<span class="hl com">	 * references to the duplicate).</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOORemoveFromMixinSubs</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>num <span class="hl opt">!=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	    <span class="hl kwd">ckfree</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>list<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">DUPLICATE</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">,</span> Class <span class="hl opt">*);</span>
	<span class="hl kwd">FOREACH</span><span class="hl opt">(</span>mixinPtr<span class="hl opt">,</span> cls2Ptr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	    <span class="hl kwd">TclOOAddToMixinSubs</span><span class="hl opt">(</span>cls2Ptr<span class="hl opt">,</span> mixinPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Duplicate the source class's methods, constructor and destructor.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>keyPtr<span class="hl opt">,</span> mPtr<span class="hl opt">, &amp;</span>clsPtr<span class="hl opt">-&gt;</span>classMethods<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">CloneClassMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> cls2Ptr<span class="hl opt">,</span> mPtr<span class="hl opt">,</span> keyPtr<span class="hl opt">,</span>
		    NULL<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>constructorPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">CloneClassMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> cls2Ptr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>constructorPtr<span class="hl opt">,</span>
		    NULL<span class="hl opt">, &amp;</span>cls2Ptr<span class="hl opt">-&gt;</span>constructorPtr<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>destructorPtr<span class="hl opt">) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">CloneClassMethod</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> cls2Ptr<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>destructorPtr<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
		    <span class="hl opt">&amp;</span>cls2Ptr<span class="hl opt">-&gt;</span>destructorPtr<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
		<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Duplicate the class's metadata.</span>
<span class="hl com">	 */</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    Tcl_ObjectMetadataType <span class="hl opt">*</span>metadataTypePtr<span class="hl opt">;</span>
	    ClientData value<span class="hl opt">,</span> duplicate<span class="hl opt">;</span>

	    <span class="hl kwd">FOREACH_HASH</span><span class="hl opt">(</span>metadataTypePtr<span class="hl opt">,</span> value<span class="hl opt">,</span> clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">) {</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>metadataTypePtr<span class="hl opt">-&gt;</span>cloneProc <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
		    duplicate <span class="hl opt">=</span> value<span class="hl opt">;</span>
		<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
		    <span class="hl kwa">if</span> <span class="hl opt">(</span>metadataTypePtr<span class="hl opt">-&gt;</span><span class="hl kwd">cloneProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> value<span class="hl opt">,</span>
			    <span class="hl opt">&amp;</span>duplicate<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
			<span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
			<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
		    <span class="hl opt">}</span>
		<span class="hl opt">}</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>duplicate <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
		    <span class="hl kwd">Tcl_ClassSetMetadata</span><span class="hl opt">((</span>Tcl_Class<span class="hl opt">)</span> cls2Ptr<span class="hl opt">,</span> metadataTypePtr<span class="hl opt">,</span>
			    duplicate<span class="hl opt">);</span>
		<span class="hl opt">}</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">TclResetRewriteEnsemble</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    contextPtr <span class="hl opt">=</span> <span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>o2Ptr<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">) {</span>
	args<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> <span class="hl kwd">TclOOObjectName</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">);</span>
	args<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">] =</span> oPtr<span class="hl opt">-&gt;</span>fPtr<span class="hl opt">-&gt;</span>clonedName<span class="hl opt">;</span>
	args<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">] =</span> <span class="hl kwd">TclOOObjectName</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]);</span>
	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]);</span>
	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">]);</span>
	result <span class="hl opt">=</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TclOOInvokeContext<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">,</span>
		args<span class="hl opt">);</span>
	<span class="hl kwd">TclDecrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]);</span>
	<span class="hl kwd">TclDecrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]);</span>
	<span class="hl kwd">TclDecrRefCount</span><span class="hl opt">(</span>args<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">]);</span>
	<span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> TCL_ERROR<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_AddErrorInfo</span><span class="hl opt">(</span>interp<span class="hl opt">,</span>
		    <span class="hl str">&quot;</span><span class="hl esc">\n</span>    <span class="hl str">(while performing post-copy callback)&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_OK<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DeleteCommandFromToken</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> o2Ptr<span class="hl opt">-&gt;</span>command<span class="hl opt">);</span>
	    <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Object<span class="hl opt">)</span> o2Ptr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * CloneObjectMethod, CloneClassMethod --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Helper functions used for cloning methods. They work identically to</span>
<span class="hl com"> *	each other, except for the difference between them in how they</span>
<span class="hl com"> *	register the cloned method on a successful clone.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">CloneObjectMethod</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">,</span>
    Method <span class="hl opt">*</span>mPtr<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwd">Tcl_NewInstanceMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">,</span> namePtr<span class="hl opt">,</span>
		mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">-&gt;</span>cloneProc<span class="hl opt">) {</span>
	ClientData newClientData<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">cloneProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>clientData<span class="hl opt">,</span>
		<span class="hl opt">&amp;</span>newClientData<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
	    <span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">Tcl_NewInstanceMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">,</span> namePtr<span class="hl opt">,</span>
		mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">,</span> newClientData<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl kwd">Tcl_NewInstanceMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">,</span> namePtr<span class="hl opt">,</span>
		mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>clientData<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">CloneClassMethod</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Class <span class="hl opt">*</span>clsPtr<span class="hl opt">,</span>
    Method <span class="hl opt">*</span>mPtr<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">,</span>
    Method <span class="hl opt">**</span>m2PtrPtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Method <span class="hl opt">*</span>m2Ptr<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	m2Ptr <span class="hl opt">= (</span>Method <span class="hl opt">*)</span> <span class="hl kwd">Tcl_NewMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Class<span class="hl opt">)</span> clsPtr<span class="hl opt">,</span>
		namePtr<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">-&gt;</span>cloneProc<span class="hl opt">) {</span>
	ClientData newClientData<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">cloneProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>clientData<span class="hl opt">,</span>
		<span class="hl opt">&amp;</span>newClientData<span class="hl opt">) !=</span> TCL_OK<span class="hl opt">) {</span>
	    <span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
	<span class="hl opt">}</span>
	m2Ptr <span class="hl opt">= (</span>Method <span class="hl opt">*)</span> <span class="hl kwd">Tcl_NewMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Class<span class="hl opt">)</span> clsPtr<span class="hl opt">,</span>
		namePtr<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">,</span>
		newClientData<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	m2Ptr <span class="hl opt">= (</span>Method <span class="hl opt">*)</span> <span class="hl kwd">Tcl_NewMethod</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Class<span class="hl opt">)</span> clsPtr<span class="hl opt">,</span>
		namePtr<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> PUBLIC_METHOD<span class="hl opt">,</span> mPtr<span class="hl opt">-&gt;</span>typePtr<span class="hl opt">,</span>
		mPtr<span class="hl opt">-&gt;</span>clientData<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>m2PtrPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl opt">*</span>m2PtrPtr <span class="hl opt">=</span> m2Ptr<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Tcl_ClassGetMetadata, Tcl_ClassSetMetadata, Tcl_ObjectGetMetadata,</span>
<span class="hl com"> * Tcl_ObjectSetMetadata --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Metadata management API. The metadata system allows code in extensions</span>
<span class="hl com"> *	to attach arbitrary non-NULL pointers to objects and classes without</span>
<span class="hl com"> *	the different things that might be interested being able to interfere</span>
<span class="hl com"> *	with each other. Apart from non-NULL-ness, these routines attach no</span>
<span class="hl com"> *	interpretation to the meaning of the metadata pointers.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	The Tcl_*GetMetadata routines get the metadata pointer attached that</span>
<span class="hl com"> *	has been related with a particular type, or NULL if no metadata</span>
<span class="hl com"> *	associated with the given type has been attached.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	The Tcl_*SetMetadata routines set or delete the metadata pointer that</span>
<span class="hl com"> *	is related to a particular type. The value associated with the type is</span>
<span class="hl com"> *	deleted (if present; no-op otherwise) if the value is NULL, and</span>
<span class="hl com"> *	attached (replacing the previous value, which is deleted if present)</span>
<span class="hl com"> *	otherwise. This means it is impossible to attach a NULL value for any</span>
<span class="hl com"> *	metadata type.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

ClientData
<span class="hl kwd">Tcl_ClassGetMetadata</span><span class="hl opt">(</span>
    Tcl_Class clazz<span class="hl opt">,</span>
    <span class="hl kwb">const</span> Tcl_ObjectMetadataType <span class="hl opt">*</span>typePtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Class <span class="hl opt">*</span>clsPtr <span class="hl opt">= (</span>Class <span class="hl opt">*)</span> clazz<span class="hl opt">;</span>
    Tcl_HashEntry <span class="hl opt">*</span>hPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If there's no metadata store attached, the type in question has</span>
<span class="hl com">     * definitely not been attached either!</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * There is a metadata store, so look in it for the given type.</span>
<span class="hl com">     */</span>

    hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_FindHashEntry</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Return the metadata value if we found it, otherwise NULL.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>hPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">Tcl_ClassSetMetadata</span><span class="hl opt">(</span>
    Tcl_Class clazz<span class="hl opt">,</span>
    <span class="hl kwb">const</span> Tcl_ObjectMetadataType <span class="hl opt">*</span>typePtr<span class="hl opt">,</span>
    ClientData metadata<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Class <span class="hl opt">*</span>clsPtr <span class="hl opt">= (</span>Class <span class="hl opt">*)</span> clazz<span class="hl opt">;</span>
    Tcl_HashEntry <span class="hl opt">*</span>hPtr<span class="hl opt">;</span>
    <span class="hl kwb">int</span> isNew<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Attach the metadata store if not done already.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>metadata <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	clsPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Tcl_HashTable<span class="hl opt">));</span>
	<span class="hl kwd">Tcl_InitHashTable</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">,</span> TCL_ONE_WORD_KEYS<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If the metadata is NULL, we're deleting the metadata for the type.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>metadata <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_FindHashEntry</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>hPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span><span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">));</span>
	    <span class="hl kwd">Tcl_DeleteHashEntry</span><span class="hl opt">(</span>hPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Otherwise we're attaching the metadata. Note that if there was already</span>
<span class="hl com">     * some metadata attached of this type, we delete that first.</span>
<span class="hl com">     */</span>

    hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateHashEntry</span><span class="hl opt">(</span>clsPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">, &amp;</span>isNew<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>isNew<span class="hl opt">) {</span>
	typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span><span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">));</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Tcl_SetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">,</span> metadata<span class="hl opt">);</span>
<span class="hl opt">}</span>

ClientData
<span class="hl kwd">Tcl_ObjectGetMetadata</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">,</span>
    <span class="hl kwb">const</span> Tcl_ObjectMetadataType <span class="hl opt">*</span>typePtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">= (</span>Object <span class="hl opt">*)</span> object<span class="hl opt">;</span>
    Tcl_HashEntry <span class="hl opt">*</span>hPtr<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If there's no metadata store attached, the type in question has</span>
<span class="hl com">     * definitely not been attached either!</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * There is a metadata store, so look in it for the given type.</span>
<span class="hl com">     */</span>

    hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_FindHashEntry</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Return the metadata value if we found it, otherwise NULL.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>hPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">Tcl_ObjectSetMetadata</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">,</span>
    <span class="hl kwb">const</span> Tcl_ObjectMetadataType <span class="hl opt">*</span>typePtr<span class="hl opt">,</span>
    ClientData metadata<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Object <span class="hl opt">*</span>oPtr <span class="hl opt">= (</span>Object <span class="hl opt">*)</span> object<span class="hl opt">;</span>
    Tcl_HashEntry <span class="hl opt">*</span>hPtr<span class="hl opt">;</span>
    <span class="hl kwb">int</span> isNew<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Attach the metadata store if not done already.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>metadata <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwa">return</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
	oPtr<span class="hl opt">-&gt;</span>metadataPtr <span class="hl opt">=</span> <span class="hl kwd">ckalloc</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>Tcl_HashTable<span class="hl opt">));</span>
	<span class="hl kwd">Tcl_InitHashTable</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">,</span> TCL_ONE_WORD_KEYS<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If the metadata is NULL, we're deleting the metadata for the type.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>metadata <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_FindHashEntry</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>hPtr <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	    typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span><span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">));</span>
	    <span class="hl kwd">Tcl_DeleteHashEntry</span><span class="hl opt">(</span>hPtr<span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Otherwise we're attaching the metadata. Note that if there was already</span>
<span class="hl com">     * some metadata attached of this type, we delete that first.</span>
<span class="hl com">     */</span>

    hPtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_CreateHashEntry</span><span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>metadataPtr<span class="hl opt">, (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span> typePtr<span class="hl opt">, &amp;</span>isNew<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>isNew<span class="hl opt">) {</span>
	typePtr<span class="hl opt">-&gt;</span><span class="hl kwd">deleteProc</span><span class="hl opt">(</span><span class="hl kwd">Tcl_GetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">));</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Tcl_SetHashValue</span><span class="hl opt">(</span>hPtr<span class="hl opt">,</span> metadata<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * PublicObjectCmd, PrivateObjectCmd, TclOOInvokeObject --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Main entry point for object invokations. The Public* and Private*</span>
<span class="hl com"> *	wrapper functions (implementations of both object instance commands</span>
<span class="hl com"> *	and [my]) are just thin wrappers round the main TclOOObjectCmdCore</span>
<span class="hl com"> *	function. Note that the core is function is NRE-aware.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">PublicObjectCmd</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> PublicNRObjectCmd<span class="hl opt">,</span> clientData<span class="hl opt">,</span>objc<span class="hl opt">,</span>objv<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">PublicNRObjectCmd</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">(</span>clientData<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">,</span> PUBLIC_METHOD<span class="hl opt">,</span>
	    NULL<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">PrivateObjectCmd</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> PrivateNRObjectCmd<span class="hl opt">,</span>clientData<span class="hl opt">,</span>objc<span class="hl opt">,</span>objv<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">PrivateNRObjectCmd</span><span class="hl opt">(</span>
    ClientData clientData<span class="hl opt">,</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">(</span>clientData<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclOOInvokeObject</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter for commands, variables,</span>
<span class="hl com">				 * results, error reporting, etc. */</span>
    Tcl_Object object<span class="hl opt">,</span>		<span class="hl com">/* The object to invoke. */</span>
    Tcl_Class startCls<span class="hl opt">,</span>		<span class="hl com">/* Where in the class chain to start the</span>
<span class="hl com">				 * invoke from, or NULL to traverse the whole</span>
<span class="hl com">				 * chain including filters. */</span>
    <span class="hl kwb">int</span> publicPrivate<span class="hl opt">,</span>		<span class="hl com">/* Whether this is an invoke from a public</span>
<span class="hl com">				 * context (PUBLIC_METHOD), a private context</span>
<span class="hl com">				 * (PRIVATE_METHOD), or a *really* private</span>
<span class="hl com">				 * context (any other value; conventionally</span>
<span class="hl com">				 * 0). */</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>			<span class="hl com">/* Number of arguments. */</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">)</span>	<span class="hl com">/* Array of argument objects. It is assumed</span>
<span class="hl com">				 * that the name of the method to invoke will</span>
<span class="hl com">				 * be at index 1. */</span>
<span class="hl opt">{</span>
    <span class="hl kwa">switch</span> <span class="hl opt">(</span>publicPrivate<span class="hl opt">) {</span>
    <span class="hl kwa">case</span> PUBLIC_METHOD<span class="hl opt">:</span>
	<span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">((</span>Object <span class="hl opt">*)</span> object<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">,</span>
		PUBLIC_METHOD<span class="hl opt">, (</span>Class <span class="hl opt">*)</span> startCls<span class="hl opt">);</span>
    <span class="hl kwa">case</span> PRIVATE_METHOD<span class="hl opt">:</span>
	<span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">((</span>Object <span class="hl opt">*)</span> object<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">,</span>
		PRIVATE_METHOD<span class="hl opt">, (</span>Class <span class="hl opt">*)</span> startCls<span class="hl opt">);</span>
    <span class="hl kwa">default</span><span class="hl opt">:</span>
	<span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">((</span>Object <span class="hl opt">*)</span> object<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>
		<span class="hl opt">(</span>Class <span class="hl opt">*)</span> startCls<span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOObjectCmdCore, FinalizeObjectCall --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Main function for object invokations. Does call chain creation,</span>
<span class="hl com"> *	management and invokation. The function FinalizeObjectCall exists to</span>
<span class="hl com"> *	clean up after the non-recursive processing of TclOOObjectCmdCore.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclOOObjectCmdCore</span><span class="hl opt">(</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">,</span>		<span class="hl com">/* The object being invoked. */</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* The interpreter containing the object. */</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>			<span class="hl com">/* How many arguments are being passed in. */</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">,</span>	<span class="hl com">/* The array of arguments. */</span>
    <span class="hl kwb">int</span> flags<span class="hl opt">,</span>			<span class="hl com">/* Whether this is an invokation through the</span>
<span class="hl com">				 * public or the private command interface. */</span>
    Class <span class="hl opt">*</span>startCls<span class="hl opt">)</span>		<span class="hl com">/* Where to start in the call chain, or NULL</span>
<span class="hl com">				 * if we are to start at the front with</span>
<span class="hl com">				 * filters and the object's methods (which is</span>
<span class="hl com">				 * the normal case). */</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr<span class="hl opt">;</span>
    Tcl_Obj <span class="hl opt">*</span>methodNamePtr<span class="hl opt">;</span>
    <span class="hl kwb">int</span> result<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If we've no method name, throw this directly into the unknown</span>
<span class="hl com">     * processing.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>objc <span class="hl opt">&lt;</span> <span class="hl num">2</span><span class="hl opt">) {</span>
	flags <span class="hl opt">|=</span> FORCE_UNKNOWN<span class="hl opt">;</span>
	methodNamePtr <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
	<span class="hl kwa">goto</span> noMapping<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Give plugged in code a chance to remap the method name.</span>
<span class="hl com">     */</span>

    methodNamePtr <span class="hl opt">=</span> objv<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">];</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>mapMethodNameProc <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwc">register</span> Class <span class="hl opt">**</span>startClsPtr <span class="hl opt">= &amp;</span>startCls<span class="hl opt">;</span>
	Tcl_Obj <span class="hl opt">*</span>mappedMethodName <span class="hl opt">=</span> <span class="hl kwd">Tcl_DuplicateObj</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">);</span>

	result <span class="hl opt">=</span> oPtr<span class="hl opt">-&gt;</span><span class="hl kwd">mapMethodNameProc</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Tcl_Object<span class="hl opt">)</span> oPtr<span class="hl opt">,</span>
		<span class="hl opt">(</span>Tcl_Class <span class="hl opt">*)</span> startClsPtr<span class="hl opt">,</span> mappedMethodName<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> TCL_OK<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>mappedMethodName<span class="hl opt">);</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> TCL_BREAK<span class="hl opt">) {</span>
		<span class="hl kwa">goto</span> noMapping<span class="hl opt">;</span>
	    <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> TCL_ERROR<span class="hl opt">) {</span>
		<span class="hl kwd">Tcl_AddErrorInfo</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\n</span>    <span class="hl str">(while mapping method name)&quot;</span><span class="hl opt">);</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">return</span> result<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Get the call chain for the remapped name.</span>
<span class="hl com">	 */</span>

	<span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>mappedMethodName<span class="hl opt">);</span>
	contextPtr <span class="hl opt">=</span> <span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> mappedMethodName<span class="hl opt">,</span>
		flags <span class="hl opt">| (</span>oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> FILTER_HANDLING<span class="hl opt">),</span> methodNamePtr<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_DecrRefCount</span><span class="hl opt">(</span>mappedMethodName<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;impossible to invoke method</span> <span class="hl esc">\&quot;</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
		    <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">),</span>
		    <span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">: no defined method or unknown method&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;LOOKUP&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;METHOD_MAPPED&quot;</span><span class="hl opt">,</span>
		    <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Get the call chain.</span>
<span class="hl com">	 */</span>

    noMapping<span class="hl opt">:</span>
	contextPtr <span class="hl opt">=</span> <span class="hl kwd">TclOOGetCallContext</span><span class="hl opt">(</span>oPtr<span class="hl opt">,</span> methodNamePtr<span class="hl opt">,</span>
		flags <span class="hl opt">| (</span>oPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> FILTER_HANDLING<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;impossible to invoke method</span> <span class="hl esc">\&quot;</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
		    <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">),</span>
		    <span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">: no defined method or unknown method&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;LOOKUP&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;METHOD&quot;</span><span class="hl opt">,</span>
		    <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Check to see if we need to apply magical tricks to start part way</span>
<span class="hl com">     * through the call chain.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>startCls <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">for</span> <span class="hl opt">(;</span> contextPtr<span class="hl opt">-&gt;</span>index <span class="hl opt">&lt;</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>numChain<span class="hl opt">;</span>
		contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">++) {</span>
	    <span class="hl kwc">register</span> <span class="hl kwb">struct</span> MInvoke <span class="hl opt">*</span>miPtr <span class="hl opt">=</span>
		    <span class="hl opt">&amp;</span>contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>chain<span class="hl opt">[</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">];</span>

	    <span class="hl kwa">if</span> <span class="hl opt">(</span>miPtr<span class="hl opt">-&gt;</span>isFilter<span class="hl opt">) {</span>
		<span class="hl kwa">continue</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>miPtr<span class="hl opt">-&gt;</span>mPtr<span class="hl opt">-&gt;</span>declaringClassPtr <span class="hl opt">==</span> startCls<span class="hl opt">) {</span>
		<span class="hl kwa">break</span><span class="hl opt">;</span>
	    <span class="hl opt">}</span>
	<span class="hl opt">}</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>index <span class="hl opt">&gt;=</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>numChain<span class="hl opt">) {</span>
	    <span class="hl kwd">Tcl_SetResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;no valid method implementation&quot;</span><span class="hl opt">,</span>
		    TCL_STATIC<span class="hl opt">);</span>
	    <span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;LOOKUP&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;METHOD&quot;</span><span class="hl opt">,</span>
		    <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>methodNamePtr<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
	    <span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">);</span>
	    <span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Invoke the call chain, locking the object structure against deletion</span>
<span class="hl com">     * for the duration.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">TclNRAddCallback</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> FinalizeObjectCall<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span> NULL<span class="hl opt">,</span>NULL<span class="hl opt">,</span>NULL<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl kwd">TclOOInvokeContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">FinalizeObjectCall</span><span class="hl opt">(</span>
    ClientData data<span class="hl opt">[],</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> result<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/*</span>
<span class="hl com">     * Dispose of the call chain, which drops the lock on the object's</span>
<span class="hl com">     * structure.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">TclOODeleteContext</span><span class="hl opt">(</span>data<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]);</span>
    <span class="hl kwa">return</span> result<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Tcl_ObjectContextInvokeNext, TclNRObjectContextInvokeNext, FinalizeNext --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Invokes the next stage of the call chain described in an object</span>
<span class="hl com"> *	context. This is the core of the implementation of the [next] command.</span>
<span class="hl com"> *	Does not do management of the call-frame stack. Available in public</span>
<span class="hl com"> *	(standard API) and private (NRE-aware) forms. FinalizeNext is a</span>
<span class="hl com"> *	private function used to clean up in the NRE case.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">int</span>
<span class="hl kwd">Tcl_ObjectContextInvokeNext</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Tcl_ObjectContext context<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">,</span>
    <span class="hl kwb">int</span> skip<span class="hl opt">)</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">= (</span>CallContext <span class="hl opt">*)</span> context<span class="hl opt">;</span>
    <span class="hl kwb">int</span> savedIndex <span class="hl opt">=</span> contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">;</span>
    <span class="hl kwb">int</span> savedSkip <span class="hl opt">=</span> contextPtr<span class="hl opt">-&gt;</span>skip<span class="hl opt">;</span>
    <span class="hl kwb">int</span> result<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">+</span><span class="hl num">1</span> <span class="hl opt">&gt;=</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>numChain<span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * We're at the end of the chain; generate an error message unless the</span>
<span class="hl com">	 * interpreter is being torn down, in which case we might be getting</span>
<span class="hl com">	 * here because of methods/destructors doing a [next] (or equivalent)</span>
<span class="hl com">	 * unexpectedly.</span>
<span class="hl com">	 */</span>

	<span class="hl kwb">const char</span> <span class="hl opt">*</span>methodType<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Tcl_InterpDeleted</span><span class="hl opt">(</span>interp<span class="hl opt">)) {</span>
	    <span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> CONSTRUCTOR<span class="hl opt">) {</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;constructor&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> DESTRUCTOR<span class="hl opt">) {</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;destructor&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;method&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;no next &quot;</span><span class="hl opt">,</span> methodType<span class="hl opt">,</span> <span class="hl str">&quot; implementation&quot;</span><span class="hl opt">,</span>
		NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;NOTHING_NEXT&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Advance to the next method implementation in the chain in the method</span>
<span class="hl com">     * call context while we process the body. However, need to adjust the</span>
<span class="hl com">     * argument-skip control because we're guaranteed to have a single prefix</span>
<span class="hl com">     * arg (i.e., 'next') and not the variable amount that can happen because</span>
<span class="hl com">     * method invokations (i.e., '$obj meth' and 'my meth'), constructors</span>
<span class="hl com">     * (i.e., '$cls new' and '$cls create obj') and destructors (no args at</span>
<span class="hl com">     * all) come through the same code.</span>
<span class="hl com">     */</span>

    contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">++;</span>
    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> skip<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Invoke the (advanced) method call context in the caller context.</span>
<span class="hl com">     */</span>

    result <span class="hl opt">=</span> <span class="hl kwd">Tcl_NRCallObjProc</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> TclOOInvokeContext<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span> objc<span class="hl opt">,</span>
	    objv<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Restore the call chain context index as we've finished the inner invoke</span>
<span class="hl com">     * and want to operate in the outer context again.</span>
<span class="hl com">     */</span>

    contextPtr<span class="hl opt">-&gt;</span>index <span class="hl opt">=</span> savedIndex<span class="hl opt">;</span>
    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> savedSkip<span class="hl opt">;</span>

    <span class="hl kwa">return</span> result<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclNRObjectContextInvokeNext</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Tcl_ObjectContext context<span class="hl opt">,</span>
    <span class="hl kwb">int</span> objc<span class="hl opt">,</span>
    Tcl_Obj <span class="hl opt">*</span><span class="hl kwb">const</span> <span class="hl opt">*</span>objv<span class="hl opt">,</span>
    <span class="hl kwb">int</span> skip<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwc">register</span> CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">= (</span>CallContext <span class="hl opt">*)</span> context<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">+</span><span class="hl num">1</span> <span class="hl opt">&gt;=</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>numChain<span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * We're at the end of the chain; generate an error message unless the</span>
<span class="hl com">	 * interpreter is being torn down, in which case we might be getting</span>
<span class="hl com">	 * here because of methods/destructors doing a [next] (or equivalent)</span>
<span class="hl com">	 * unexpectedly.</span>
<span class="hl com">	 */</span>

	<span class="hl kwb">const char</span> <span class="hl opt">*</span>methodType<span class="hl opt">;</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">Tcl_InterpDeleted</span><span class="hl opt">(</span>interp<span class="hl opt">)) {</span>
	    <span class="hl kwa">return</span> TCL_OK<span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwa">if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> CONSTRUCTOR<span class="hl opt">) {</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;constructor&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> DESTRUCTOR<span class="hl opt">) {</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;destructor&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    methodType <span class="hl opt">=</span> <span class="hl str">&quot;method&quot;</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;no next &quot;</span><span class="hl opt">,</span> methodType<span class="hl opt">,</span> <span class="hl str">&quot; implementation&quot;</span><span class="hl opt">,</span>
		NULL<span class="hl opt">);</span>
	<span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OO&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;NOTHING_NEXT&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
	<span class="hl kwa">return</span> TCL_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Advance to the next method implementation in the chain in the method</span>
<span class="hl com">     * call context while we process the body. However, need to adjust the</span>
<span class="hl com">     * argument-skip control because we're guaranteed to have a single prefix</span>
<span class="hl com">     * arg (i.e., 'next') and not the variable amount that can happen because</span>
<span class="hl com">     * method invokations (i.e., '$obj meth' and 'my meth'), constructors</span>
<span class="hl com">     * (i.e., '$cls new' and '$cls create obj') and destructors (no args at</span>
<span class="hl com">     * all) come through the same code.</span>
<span class="hl com">     */</span>

    <span class="hl kwd">TclNRAddCallback</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> FinalizeNext<span class="hl opt">,</span> contextPtr<span class="hl opt">,</span>
	    <span class="hl kwd">INT2PTR</span><span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">),</span> <span class="hl kwd">INT2PTR</span><span class="hl opt">(</span>contextPtr<span class="hl opt">-&gt;</span>skip<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
    contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">++;</span>
    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> skip<span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Invoke the (advanced) method call context in the caller context.</span>
<span class="hl com">     */</span>

    <span class="hl kwa">return</span> <span class="hl kwd">TclOOInvokeContext</span><span class="hl opt">(</span>contextPtr<span class="hl opt">,</span> interp<span class="hl opt">,</span> objc<span class="hl opt">,</span> objv<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">FinalizeNext</span><span class="hl opt">(</span>
    ClientData data<span class="hl opt">[],</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    <span class="hl kwb">int</span> result<span class="hl opt">)</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">=</span> data<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">];</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Restore the call chain context index as we've finished the inner invoke</span>
<span class="hl com">     * and want to operate in the outer context again.</span>
<span class="hl com">     */</span>

    contextPtr<span class="hl opt">-&gt;</span>index <span class="hl opt">=</span> <span class="hl kwd">PTR2INT</span><span class="hl opt">(</span>data<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]);</span>
    contextPtr<span class="hl opt">-&gt;</span>skip <span class="hl opt">=</span> <span class="hl kwd">PTR2INT</span><span class="hl opt">(</span>data<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">]);</span>
    <span class="hl kwa">return</span> result<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Tcl_GetObjectFromObj --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function to get an object from a Tcl_Obj containing its name.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Tcl_Object
<span class="hl kwd">Tcl_GetObjectFromObj</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>		<span class="hl com">/* Interpreter in which to locate the object.</span>
<span class="hl com">				 * Will have an error message placed in it if</span>
<span class="hl com">				 * the name does not refer to an object. */</span>
    Tcl_Obj <span class="hl opt">*</span>objPtr<span class="hl opt">)</span>		<span class="hl com">/* The name of the object to look up, which is</span>
<span class="hl com">				 * exactly the name of its public command. */</span>
<span class="hl opt">{</span>
    Command <span class="hl opt">*</span>cmdPtr <span class="hl opt">= (</span>Command <span class="hl opt">*)</span> <span class="hl kwd">Tcl_GetCommandFromObj</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> objPtr<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>cmdPtr <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
	<span class="hl kwa">goto</span> notAnObject<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>cmdPtr<span class="hl opt">-&gt;</span>objProc <span class="hl opt">!=</span> PublicObjectCmd<span class="hl opt">) {</span>
	cmdPtr <span class="hl opt">= (</span>Command <span class="hl opt">*)</span> <span class="hl kwd">TclGetOriginalCommand</span><span class="hl opt">((</span>Tcl_Command<span class="hl opt">)</span> cmdPtr<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>cmdPtr <span class="hl opt">==</span> NULL <span class="hl opt">||</span> cmdPtr<span class="hl opt">-&gt;</span>objProc <span class="hl opt">!=</span> PublicObjectCmd<span class="hl opt">) {</span>
	    <span class="hl kwa">goto</span> notAnObject<span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> cmdPtr<span class="hl opt">-&gt;</span>objClientData<span class="hl opt">;</span>

  notAnObject<span class="hl opt">:</span>
    <span class="hl kwd">Tcl_AppendResult</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>objPtr<span class="hl opt">),</span>
	    <span class="hl str">&quot; does not refer to an object&quot;</span><span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_SetErrorCode</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> <span class="hl str">&quot;TCL&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;LOOKUP&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;OBJECT&quot;</span><span class="hl opt">,</span> <span class="hl kwd">TclGetString</span><span class="hl opt">(</span>objPtr<span class="hl opt">),</span>
	    NULL<span class="hl opt">);</span>
    <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOIsReachable --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function that tests whether a class is a subclass (whether</span>
<span class="hl com"> *	directly or indirectly) of another class.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl kwb">int</span>
<span class="hl kwd">TclOOIsReachable</span><span class="hl opt">(</span>
    Class <span class="hl opt">*</span>targetPtr<span class="hl opt">,</span>
    Class <span class="hl opt">*</span>startPtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    Class <span class="hl opt">*</span>superPtr<span class="hl opt">;</span>

  tailRecurse<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>startPtr <span class="hl opt">==</span> targetPtr<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>startPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>num <span class="hl opt">==</span> <span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> startPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">.</span>num <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
	startPtr <span class="hl opt">=</span> startPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">.</span>list<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">];</span>
	<span class="hl kwa">goto</span> tailRecurse<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>superPtr<span class="hl opt">,</span> startPtr<span class="hl opt">-&gt;</span>superclasses<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">TclOOIsReachable</span><span class="hl opt">(</span>targetPtr<span class="hl opt">,</span> superPtr<span class="hl opt">)) {</span>
	    <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">FOREACH</span><span class="hl opt">(</span>superPtr<span class="hl opt">,</span> startPtr<span class="hl opt">-&gt;</span>mixins<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">TclOOIsReachable</span><span class="hl opt">(</span>targetPtr<span class="hl opt">,</span> superPtr<span class="hl opt">)) {</span>
	    <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * TclOOObjectName, Tcl_GetObjectName --</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Utility function that returns the name of the object. Note that this</span>
<span class="hl com"> *	simplifies cache management by keeping the code to do it in one place</span>
<span class="hl com"> *	and not sprayed all over. The value returned always has a reference</span>
<span class="hl com"> *	count of at least one.</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Tcl_Obj <span class="hl opt">*</span>
<span class="hl kwd">TclOOObjectName</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Object <span class="hl opt">*</span>oPtr<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Tcl_Obj <span class="hl opt">*</span>namePtr<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">) {</span>
	<span class="hl kwa">return</span> oPtr<span class="hl opt">-&gt;</span>cachedNameObj<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    namePtr <span class="hl opt">=</span> <span class="hl kwd">Tcl_NewObj</span><span class="hl opt">();</span>
    <span class="hl kwd">Tcl_GetCommandFullName</span><span class="hl opt">(</span>interp<span class="hl opt">,</span> oPtr<span class="hl opt">-&gt;</span>command<span class="hl opt">,</span> namePtr<span class="hl opt">);</span>
    <span class="hl kwd">Tcl_IncrRefCount</span><span class="hl opt">(</span>namePtr<span class="hl opt">);</span>
    oPtr<span class="hl opt">-&gt;</span>cachedNameObj <span class="hl opt">=</span> namePtr<span class="hl opt">;</span>
    <span class="hl kwa">return</span> namePtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Obj <span class="hl opt">*</span>
<span class="hl kwd">Tcl_GetObjectName</span><span class="hl opt">(</span>
    Tcl_Interp <span class="hl opt">*</span>interp<span class="hl opt">,</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">TclOOObjectName</span><span class="hl opt">(</span>interp<span class="hl opt">, (</span>Object <span class="hl opt">*)</span> object<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * assorted trivial 'getter' functions</span>
<span class="hl com"> *</span>
<span class="hl com"> * ----------------------------------------------------------------------</span>
<span class="hl com"> */</span>

Tcl_Method
<span class="hl kwd">Tcl_ObjectContextMethod</span><span class="hl opt">(</span>
    Tcl_ObjectContext context<span class="hl opt">)</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">= (</span>CallContext <span class="hl opt">*)</span> context<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Method<span class="hl opt">)</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>chain<span class="hl opt">[</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">].</span>mPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">Tcl_ObjectContextIsFiltering</span><span class="hl opt">(</span>
    Tcl_ObjectContext context<span class="hl opt">)</span>
<span class="hl opt">{</span>
    CallContext <span class="hl opt">*</span>contextPtr <span class="hl opt">= (</span>CallContext <span class="hl opt">*)</span> context<span class="hl opt">;</span>
    <span class="hl kwa">return</span> contextPtr<span class="hl opt">-&gt;</span>callPtr<span class="hl opt">-&gt;</span>chain<span class="hl opt">[</span>contextPtr<span class="hl opt">-&gt;</span>index<span class="hl opt">].</span>isFilter<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Object
<span class="hl kwd">Tcl_ObjectContextObject</span><span class="hl opt">(</span>
    Tcl_ObjectContext context<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Object<span class="hl opt">) ((</span>CallContext <span class="hl opt">*)</span>context<span class="hl opt">)-&gt;</span>oPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">Tcl_ObjectContextSkippedArgs</span><span class="hl opt">(</span>
    Tcl_ObjectContext context<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">((</span>CallContext <span class="hl opt">*)</span>context<span class="hl opt">)-&gt;</span>skip<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Namespace <span class="hl opt">*</span>
<span class="hl kwd">Tcl_GetObjectNamespace</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">((</span>Object <span class="hl opt">*)</span>object<span class="hl opt">)-&gt;</span>namespacePtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Command
<span class="hl kwd">Tcl_GetObjectCommand</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">((</span>Object <span class="hl opt">*)</span>object<span class="hl opt">)-&gt;</span>command<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Class
<span class="hl kwd">Tcl_GetObjectAsClass</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Class<span class="hl opt">) ((</span>Object <span class="hl opt">*)</span>object<span class="hl opt">)-&gt;</span>classPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">Tcl_ObjectDeleted</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Deleted</span><span class="hl opt">(</span>object<span class="hl opt">)</span> ? <span class="hl num">1</span> <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_Object
<span class="hl kwd">Tcl_GetClassAsObject</span><span class="hl opt">(</span>
    Tcl_Class clazz<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>Tcl_Object<span class="hl opt">) ((</span>Class <span class="hl opt">*)</span>clazz<span class="hl opt">)-&gt;</span>thisPtr<span class="hl opt">;</span>
<span class="hl opt">}</span>

Tcl_ObjectMapMethodNameProc <span class="hl opt">*</span>
<span class="hl kwd">Tcl_ObjectGetMethodNameMapper</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">((</span>Object <span class="hl opt">*)</span> object<span class="hl opt">)-&gt;</span>mapMethodNameProc<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">Tcl_ObjectSetMethodNameMapper</span><span class="hl opt">(</span>
    Tcl_Object object<span class="hl opt">,</span>
    Tcl_ObjectMapMethodNameProc <span class="hl opt">*</span>mapMethodNameProc<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl opt">((</span>Object <span class="hl opt">*)</span> object<span class="hl opt">)-&gt;</span>mapMethodNameProc <span class="hl opt">=</span> mapMethodNameProc<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> * Local Variables:</span>
<span class="hl com"> * mode: c</span>
<span class="hl com"> * c-basic-offset: 4</span>
<span class="hl com"> * fill-column: 78</span>
<span class="hl com"> * End:</span>
<span class="hl com"> */</span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit v0.12</a> at 2025-11-07 19:59:00 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>