def process_muv(self, infile):
     tmpfile = infile
     if tmpfile[-4:] == ".muv":
         tmpfile = tmpfile[:-1] + 'f'
     else:
         tmpfile += ".muf"
     if "MufSim.app/Contents/Resources" in os.getcwd():
         muvdir = os.path.join(os.getcwd(), "muv")
         cmdarr = [
             os.path.join(muvdir, "muv"),
             "-I", os.path.join(muvdir, "incls"),
             "-o", tmpfile,
             infile
         ]
     else:
         cmdarr = ["muv", "-o", tmpfile, infile]
     p = Popen(cmdarr, stdout=PIPE, stderr=PIPE)
     outdata, errdata = p.communicate()
     outdata = outdata.decode()
     errdata = errdata.decode()
     for line in outdata.split("\n"):
         if line:
             log(line)
     for line in errdata.split("\n"):
         if line:
             errlog(line)
     if p.returncode != 0:
         errlog("MUV compilation failed!")
         return None
     log("MUV compilation successful.", msgtype="good")
     return tmpfile

 def show_compiled_tokens(self, prog):
     alltokens = self.fr.program_tokens(prog)
     for inum, tokeninfo in enumerate(alltokens):
         rep = tokeninfo['repr']
         if inum > 0 and rep.startswith("Function:"):
             log("")
         log("% 5d: %s" % (inum, rep))

 def compile(self, cmplr, code, src):
     nam, src = cmplr.get_word(src)
     comp = cmplr.compiled
     if not comp.publicize_function(nam):
         raise MufCompileError("Unrecognized identifier: %s" % nam)
     log("EXPOSED '%s' AS PUBLIC" % nam)
     return (False, src)

 def execute(self, fr):
     con = fr.data_pop(int)
     descr = conn.descr_from_con(con)
     if descr >= 0:
         who = conn.descr_user(descr)
         conn.disconnect(descr)
         log("BOOTED DESCRIPTOR %d: %s" % (descr, db.getobj(who)))

 def debug_cmd_print(self, args):
     addr = self.fr.curr_addr()
     vname = args
     muvname = ("_%s" % vname).replace("::", "__")
     fun = self.fr.program_find_func(addr)
     if self.fr.program_func_var(addr.prog, fun, vname):
         v = self.fr.program_func_var(addr.prog, fun, vname)
         val = self.fr.funcvar_get(v)
     elif self.fr.program_global_var(addr.prog, vname):
         v = self.fr.program_global_var(addr.prog, vname)
         val = self.fr.globalvar_get(v)
     elif self.fr.program_func_var(addr.prog, fun, muvname):
         v = self.fr.program_func_var(addr.prog, fun, muvname)
         val = self.fr.funcvar_get(v)
         vname = muvname
     elif self.fr.program_global_var(addr.prog, muvname):
         v = self.fr.program_global_var(addr.prog, muvname)
         val = self.fr.globalvar_get(v)
         vname = muvname
     else:
         log("Variable not found: %s" % vname)
         val = None
     if val is not None:
         val = si.item_repr(val)
         log("%s = %s" % (vname, val))

 def execute(self, fr):
     # TODO: make real timed read.
     fr.data_pop(int)
     while True:
         if fr.text_entry:
             txt = fr.text_entry.pop(0)
         else:
             fr.wait_state = fr.WAIT_READ
             raise MufBreakExecution()
         if txt or fr.read_wants_blanks:
             break
         log("Blank line ignored.")
     if txt == "@T":
         log("Faking time-out.")
         fr.data_push("")
         fr.data_push(1)
     elif txt == "@Q":
         while fr.call_stack:
             fr.call_pop()
         while fr.catch_stack:
             fr.catch_pop()
         raise MufRuntimeError("Aborting program.")
     else:
         fr.data_push(txt)
         fr.data_push(0)

 def debug_cmd_delete(self, args):
     bps = self.fr.get_breakpoints()
     if not util.is_int(args) or int(args) - 1 not in list(range(len(bps))):
         log("Usage: delete BREAKPOINTNUM")
     else:
         self.fr.del_breakpoint(int(args) - 1)
         log("Deleted breakpoint %d." % int(args))

 def handle_key_tab(self, event):
     curridx = self.index(INSERT)
     currline, currpos = [int(i) for i in curridx.split('.')]
     line = self.get('insert linestart', 'insert lineend')
     indent = len(line) - len(line.lstrip())
     toadd = 4 - (indent % 4)
     if currpos <= indent:
         self.insert('insert linestart', ' ' * toadd)
     elif not self.get("insert-1c", "insert").lstrip():
         self.insert(INSERT, ' ' * 4)
     else:
         word = self.get("insert-1c wordstart", "insert")
         words = [
             x for x in (
                 list(primitives.keys()) +
                 list(MufCompiler.builtin_defines.keys())
             )
             if x.startswith(word)
         ]
         words.sort()
         pfx = util.common_prefix(words)
         if len(pfx) > len(word):
             self.delete("insert-1c wordstart", "insert")
             self.insert(INSERT, pfx)
             self._syntax_hilite_line(INSERT)
         else:
             if len(words) > 1:
                 log("Completion: %s" % ", ".join(words))
             self.bell()
     return 'break'

 def next_prop(self, prop, suppress=False):
     if not prop or prop[-1] == '/':
         prop = self.normalize_prop(prop)
         if prop:
             pfx = prop + '/'
         else:
             pfx = ''
         prev = ''
     else:
         prop = self.normalize_prop(prop)
         if '/' in prop:
             pfx, prev = prop.rsplit('/', 1)
             pfx += '/'
         else:
             pfx = ''
             prev = prop
     plen = len(pfx)
     out = ''
     for prp in self.properties:
         prp = self.normalize_prop(prp)
         if prp.startswith(pfx):
             sub = prp[plen:].split('/', 1)[0]
             if sub > prev:
                 if not out or pfx + sub < out:
                     out = pfx + sub
     if not suppress:
         log("NEXTPROP \"%s\" on #%d = \"%s\"" % (prop, self.dbref, out))
     return out

 def execute_code(self, level=-1):
     maxcycles = {
         self.MODE_PREEMPT: 999999999,
         self.MODE_FOREGROUND: 10000,
         self.MODE_BACKGROUND: 10000,
     }
     level += len(self.call_stack) if level < 0 else 0
     starttime = time.time()
     self.prev_call_level = level + 1
     addr = self.curr_addr()
     inst = self.get_inst(addr)
     self.prevline = (addr.prog, inst.line)
     slice_cycles = 0
     while self.call_stack:
         addr = self.curr_addr()
         inst = self.get_inst(addr)
         if self.trace:
             log(self.get_trace_line(), msgtype='trace')
         try:
             try:
                 self.cycles += 1
                 slice_cycles += 1
                 inst.execute(self)
                 self.pc_advance(1)
                 if slice_cycles >= maxcycles[self.execution_mode]:
                     self.sleep(0.0)
                 self.check_breakpoints()
             except (MufRuntimeError, db.InvalidObjectError) as e:
                 if not self.catch_trigger(e):
                     self.runtime += time.time() - starttime
                     return
                 self.check_breakpoints()
         except MufBreakExecution as e:
             self.runtime += time.time() - starttime
             return

 def process_reads(self):
     self.poll_network()
     for pid in list(self.reading_processes.values()):
         ofr = self.processes.get(pid)
         if not ofr:
             continue
         while True:
             if ofr.text_entry:
                 cmd = ofr.text_entry.pop(0)
             elif not netifc.user_descrs(ofr.user.value):
                 cmd = self.read_handler()
             else:
                 break
             if cmd is None or cmd == '@Q':
                 log("Aborting program.")
                 del self.reading_processes[ofr.user.value]
                 self.process_complete(ofr.pid)
                 break
             if not cmd and not ofr.read_wants_blanks:
                 warnlog("Blank line ignored.")
                 continue
             ofr.data_push(cmd)
             ofr.pc_advance(1)
             del self.reading_processes[ofr.user.value]
             self.queue_process(ofr)
             break

 def run_code(self):
     self.readline_setup()
     userobj = db.get_player_obj("John_Doe")
     progobj = db.get_registered_obj(userobj, "$cmd/test")
     trigobj = db.get_registered_obj(userobj, "$testaction")
     fr = process_list.new_process()
     fr.setup(
         progobj,
         userobj,
         trigobj,
         self.opts.command
     )
     fr.set_trace(self.opts.trace)
     fr.set_text_entry(self.opts.textentry)
     dbg = ConsoleMufDebugger(fr)
     if self.opts.debug:
         dbg.debug_code()
     else:
         st = time.time()
         dbg.resume_execution()
         et = time.time()
         log("Execution completed in %d steps." % fr.cycles)
         if self.opts.timing:
             log("%g secs elapsed.  %g instructions/sec" %
                 (et-st, fr.cycles/(et-st)))
     self.readline_teardown()

 def execute_code(self, level=-1):
     level += len(self.call_stack) if level < 0 else 0
     self.prev_call_level = level + 1
     addr = self.curr_addr()
     inst = self.get_inst(addr)
     self.prevline = (addr.prog, inst.line)
     self.wait_state = self.WAIT_NONE
     while self.call_stack:
         addr = self.curr_addr()
         inst = self.get_inst(addr)
         if self.trace:
             log(self.get_trace_line(), msgtype='trace')
             sys.stdout.flush()
         try:
             self.cycles += 1
             inst.execute(self)
             self.pc_advance(1)
         except MufBreakExecution as e:
             return
         except (MufRuntimeError, db.InvalidObjectError) as e:
             if not self.catch_trigger(e):
                 return
         finally:
             try:
                 self.check_breakpoints()
             except MufBreakExecution as e:
                 return

 def execute(self, fr):
     con = fr.data_pop(int)
     descr = netifc.descr_from_con(con)
     if descr >= 0:
         who = netifc.descr_dbref(descr)
         netifc.descr_disconnect(descr)
         log("BOOTED DESCRIPTOR %d: %s" % (descr, db.getobj(who)))

 def execute(self, fr):
     fr.check_underflow(2)
     cmd = fr.data_pop(str)
     obj = fr.data_pop_object()
     log("FORCE %s TO DO: %s" % (obj, cmd))
     cmds.force_level_push(fr.user, fr.program)
     cmds.process_command(fr.proclist, -1, obj.dbref, cmd)
     cmds.force_level_pop()

 def execute(self, fr):
     fr.check_underflow(2)
     msg = fr.data_pop(str)
     descr = fr.data_pop(int)
     who = conn.descr_user(descr)
     if conn.is_descr_online(descr):
         log("NOTIFY TO DESCR %d, %s: %s" %
             (descr, db.getobj(who), msg))

 def unblessprop(self, prop, suppress=False):
     prop = self.normalize_prop(prop)
     self.mark_modify()
     if prop in self.properties:
         del self.blessed_properties[prop]
     if not suppress:
         log("UNBLESSPROP \"%s\" on #%d" % (prop, self.dbref))
     return

 def handle_stack_item_dblclick(self, event):
     w = event.widget
     index = w.index("@%s,%s" % (event.x, event.y))
     if index and self.fr:
         item = int(float(index))
         val = self.fr.data_pick(item)
         val = si.item_repr_pretty(val)
         log("pick(%d) = %s" % (item, val))

 def blessprop(self, prop, suppress=False):
     prop = self.normalize_prop(prop)
     self.mark_modify()
     if prop in self.properties:
         self.blessed_properties[prop] = 1
     if not suppress:
         log('BLESSPROP "%s" on #%d' % (prop, self.dbref))
     return

 def debug_cmd_run(self, args):
     userobj = db.get_player_obj("John_Doe")
     progobj = db.get_registered_obj(userobj, "$cmd/test")
     trigobj = db.get_registered_obj(userobj, "$testaction")
     self.fr = process_list.new_process()
     self.fr.setup(progobj, userobj, trigobj, self.opts.command)
     log("Restarting program.")
     self.debug_cmd_list("")