[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / lib / python2.4 / idlelib / ScriptBinding.py

"""Extension to execute code outside the Python shell window.

This adds the following commands:

- Check module does a full syntax check of the current module.
  It also runs the tabnanny to catch any inconsistent tabs.

- Run module executes the module's code in the __main__ namespace.  The window
  must have been saved previously. The module is added to sys.modules, and is
  also added to the __main__ namespace.

XXX GvR Redesign this interface (yet again) as follows:

- Present a dialog box for ``Run Module''

- Allow specify command line arguments in the dialog box

"""

import os
import re
import string
import tabnanny
import tokenize
import tkMessageBox
import PyShell

from configHandler import idleConf

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

indent_message = """Error: Inconsistent indentation detected!

This means that either:

1) your indentation is outright incorrect (easy to fix), or

2) your indentation mixes tabs and spaces in a way that depends on \
how many spaces a tab is worth.

To fix case 2, change all tabs to spaces by using Select All followed \
by Untabify Region (both in the Edit menu)."""


class ScriptBinding:

    menudefs = [
        ('run', [None,
                 ('Check Module', '<<check-module>>'),
                 ('Run Module', '<<run-module>>'), ]), ]

    def __init__(self, editwin):
        self.editwin = editwin
        # Provide instance variables referenced by Debugger
        # XXX This should be done differently
        self.flist = self.editwin.flist
        self.root = self.flist.root

    def check_module_event(self, event):
        filename = self.getfilename()
        if not filename:
            return
        if not self.tabnanny(filename):
            return
        self.checksyntax(filename)

    def tabnanny(self, filename):
        f = open(filename, 'r')
        try:
            tabnanny.process_tokens(tokenize.generate_tokens(f.readline))
        except tokenize.TokenError, msg:
            msgtxt, (lineno, start) = msg
            self.editwin.gotoline(lineno)
            self.errorbox("Tabnanny Tokenizing Error",
                          "Token Error: %s" % msgtxt)
            return False
        except tabnanny.NannyNag, nag:
            # The error messages from tabnanny are too confusing...
            self.editwin.gotoline(nag.get_lineno())
            self.errorbox("Tab/space error", indent_message)
            return False
        return True

    def checksyntax(self, filename):
        self.shell = shell = self.flist.open_shell()
        saved_stream = shell.get_warning_stream()
        shell.set_warning_stream(shell.stderr)
        f = open(filename, 'r')
        source = f.read()
        f.close()
        if '\r' in source:
            source = re.sub(r"\r\n", "\n", source)
            source = re.sub(r"\r", "\n", source)
        if source and source[-1] != '\n':
            source = source + '\n'
        text = self.editwin.text
        text.tag_remove("ERROR", "1.0", "end")
        try:
            try:
                # If successful, return the compiled code
                return compile(source, filename, "exec")
            except (SyntaxError, OverflowError), err:
                try:
                    msg, (errorfilename, lineno, offset, line) = err
                    if not errorfilename:
                        err.args = msg, (filename, lineno, offset, line)
                        err.filename = filename
                    self.colorize_syntax_error(msg, lineno, offset)
                except:
                    msg = "*** " + str(err)
                self.errorbox("Syntax error",
                              "There's an error in your program:\n" + msg)
                return False
        finally:
            shell.set_warning_stream(saved_stream)

    def colorize_syntax_error(self, msg, lineno, offset):
        text = self.editwin.text
        pos = "0.0 + %d lines + %d chars" % (lineno-1, offset-1)
        text.tag_add("ERROR", pos)
        char = text.get(pos)
        if char and char in 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 run_module_event(self, event):
        """Run the module after setting up the environment.

        First check the syntax.  If OK, make sure the shell is active and
        then transfer the arguments, set the run environment's working
        directory to the directory of the module being executed and also
        add that directory to its sys.path if not already included.

        """
        filename = self.getfilename()
        if not filename:
            return
        code = self.checksyntax(filename)
        if not code:
            return
        shell = self.shell
        interp = shell.interp
        if PyShell.use_subprocess:
            shell.restart_shell()
        dirname = os.path.dirname(filename)
        # XXX Too often this discards arguments the user just set...
        interp.runcommand("""if 1:
            _filename = %r
            import sys as _sys
            from os.path import basename as _basename
            if (not _sys.argv or
                _basename(_sys.argv[0]) != _basename(_filename)):
                _sys.argv = [_filename]
            import os as _os
            _os.chdir(%r)
            del _filename, _sys, _basename, _os
            \n""" % (filename, dirname))
        interp.prepend_syspath(filename)
        # XXX KBK 03Jul04 When run w/o subprocess, runtime warnings still
        #         go to __stderr__.  With subprocess, they go to the shell.
        #         Need to change streams in PyShell.ModifiedInterpreter.
        interp.runcode(code)

    def getfilename(self):
        """Get source filename.  If not saved, offer to save (or create) file

        The debugger requires a source file.  Make sure there is one, and that
        the current version of the source buffer has been saved.  If the user
        declines to save or cancels the Save As dialog, return None.

        If the user has configured IDLE for Autosave, the file will be
        silently saved if it already exists and is dirty.

        """
        filename = self.editwin.io.filename
        if not self.editwin.get_saved():
            autosave = idleConf.GetOption('main', 'General',
                                          'autosave', type='bool')
            if autosave and filename:
                self.editwin.io.save(None)
            else:
                reply = self.ask_save_dialog()
                self.editwin.text.focus_set()
                if reply == "ok":
                    self.editwin.io.save(None)
                    filename = self.editwin.io.filename
                else:
                    filename = None
        return filename

    def ask_save_dialog(self):
        msg = "Source Must Be Saved\n" + 5*' ' + "OK to Save?"
        mb = tkMessageBox.Message(title="Save Before Run or Check",
                                  message=msg,
                                  icon=tkMessageBox.QUESTION,
                                  type=tkMessageBox.OKCANCEL,
                                  default=tkMessageBox.OK,
                                  master=self.editwin.text)
        return mb.show()

    def errorbox(self, title, message):
        # XXX This should really be a function of EditorWindow...
        tkMessageBox.showerror(title, message, master=self.editwin.text)
        self.editwin.text.focus_set()
Commit	Line	Data
920dae64 AT	1	"""Extension to execute code outside the Python shell window.
	2
	3	This adds the following commands:
	4
	5	- Check module does a full syntax check of the current module.
	6	It also runs the tabnanny to catch any inconsistent tabs.
	7
	8	- Run module executes the module's code in the __main__ namespace. The window
	9	must have been saved previously. The module is added to sys.modules, and is
	10	also added to the __main__ namespace.
	11
	12	XXX GvR Redesign this interface (yet again) as follows:
	13
	14	- Present a dialog box for ``Run Module''
	15
	16	- Allow specify command line arguments in the dialog box
	17
	18	"""
	19
	20	import os
	21	import re
	22	import string
	23	import tabnanny
	24	import tokenize
	25	import tkMessageBox
	26	import PyShell
	27
	28	from configHandler import idleConf
	29
	30	IDENTCHARS = string.ascii_letters + string.digits + "_"
	31
	32	indent_message = """Error: Inconsistent indentation detected!
	33
	34	This means that either:
	35
	36	1) your indentation is outright incorrect (easy to fix), or
	37
	38	2) your indentation mixes tabs and spaces in a way that depends on \
	39	how many spaces a tab is worth.
	40
	41	To fix case 2, change all tabs to spaces by using Select All followed \
	42	by Untabify Region (both in the Edit menu)."""
	43
	44
	45	class ScriptBinding:
	46
	47	menudefs = [
	48	('run', [None,
	49	('Check Module', '<<check-module>>'),
	50	('Run Module', '<<run-module>>'), ]), ]
	51
	52	def __init__(self, editwin):
	53	self.editwin = editwin
	54	# Provide instance variables referenced by Debugger
	55	# XXX This should be done differently
	56	self.flist = self.editwin.flist
	57	self.root = self.flist.root
	58
	59	def check_module_event(self, event):
	60	filename = self.getfilename()
	61	if not filename:
	62	return
	63	if not self.tabnanny(filename):
	64	return
65	self.checksyntax(filename)
66
67	def tabnanny(self, filename):
68	f = open(filename, 'r')
69	try:
70	tabnanny.process_tokens(tokenize.generate_tokens(f.readline))
71	except tokenize.TokenError, msg:
72	msgtxt, (lineno, start) = msg
73	self.editwin.gotoline(lineno)
74	self.errorbox("Tabnanny Tokenizing Error",
75	"Token Error: %s" % msgtxt)
76	return False
77	except tabnanny.NannyNag, nag:
78	# The error messages from tabnanny are too confusing...
79	self.editwin.gotoline(nag.get_lineno())
80	self.errorbox("Tab/space error", indent_message)
81	return False
82	return True
83
84	def checksyntax(self, filename):
85	self.shell = shell = self.flist.open_shell()
86	saved_stream = shell.get_warning_stream()
87	shell.set_warning_stream(shell.stderr)
88	f = open(filename, 'r')
89	source = f.read()
90	f.close()
91	if '\r' in source:
92	source = re.sub(r"\r\n", "\n", source)
93	source = re.sub(r"\r", "\n", source)
94	if source and source[-1] != '\n':
95	source = source + '\n'
96	text = self.editwin.text
97	text.tag_remove("ERROR", "1.0", "end")
98	try:
99	try:
100	# If successful, return the compiled code
101	return compile(source, filename, "exec")
102	except (SyntaxError, OverflowError), err:
103	try:
104	msg, (errorfilename, lineno, offset, line) = err
105	if not errorfilename:
106	err.args = msg, (filename, lineno, offset, line)
107	err.filename = filename
108	self.colorize_syntax_error(msg, lineno, offset)
109	except:
110	msg = "*** " + str(err)
111	self.errorbox("Syntax error",
112	"There's an error in your program:\n" + msg)
113	return False
114	finally:
115	shell.set_warning_stream(saved_stream)
116
117	def colorize_syntax_error(self, msg, lineno, offset):
118	text = self.editwin.text
119	pos = "0.0 + %d lines + %d chars" % (lineno-1, offset-1)
120	text.tag_add("ERROR", pos)
121	char = text.get(pos)
122	if char and char in IDENTCHARS:
123	text.tag_add("ERROR", pos + " wordstart", pos)
124	if '\n' == text.get(pos): # error at line end
125	text.mark_set("insert", pos)
126	else:
127	text.mark_set("insert", pos + "+1c")
128	text.see(pos)
129
130	def run_module_event(self, event):
131	"""Run the module after setting up the environment.
132
133	First check the syntax. If OK, make sure the shell is active and
134	then transfer the arguments, set the run environment's working
135	directory to the directory of the module being executed and also
136	add that directory to its sys.path if not already included.
137
138	"""
139	filename = self.getfilename()
140	if not filename:
141	return
142	code = self.checksyntax(filename)
143	if not code:
144	return
145	shell = self.shell
146	interp = shell.interp
147	if PyShell.use_subprocess:
148	shell.restart_shell()
149	dirname = os.path.dirname(filename)
150	# XXX Too often this discards arguments the user just set...
151	interp.runcommand("""if 1:
152	_filename = %r
153	import sys as _sys
154	from os.path import basename as _basename
155	if (not _sys.argv or
156	_basename(_sys.argv[0]) != _basename(_filename)):
157	_sys.argv = [_filename]
158	import os as _os
159	_os.chdir(%r)
160	del _filename, _sys, _basename, _os
161	\n""" % (filename, dirname))
162	interp.prepend_syspath(filename)
163	# XXX KBK 03Jul04 When run w/o subprocess, runtime warnings still
164	# go to __stderr__. With subprocess, they go to the shell.
165	# Need to change streams in PyShell.ModifiedInterpreter.
166	interp.runcode(code)
167
168	def getfilename(self):
169	"""Get source filename. If not saved, offer to save (or create) file
170
171	The debugger requires a source file. Make sure there is one, and that
172	the current version of the source buffer has been saved. If the user
173	declines to save or cancels the Save As dialog, return None.
174
175	If the user has configured IDLE for Autosave, the file will be
176	silently saved if it already exists and is dirty.
177
178	"""
179	filename = self.editwin.io.filename
180	if not self.editwin.get_saved():
181	autosave = idleConf.GetOption('main', 'General',
182	'autosave', type='bool')
183	if autosave and filename:
184	self.editwin.io.save(None)
185	else:
186	reply = self.ask_save_dialog()
187	self.editwin.text.focus_set()
188	if reply == "ok":
189	self.editwin.io.save(None)
190	filename = self.editwin.io.filename
191	else:
192	filename = None
193	return filename
194
195	def ask_save_dialog(self):
196	msg = "Source Must Be Saved\n" + 5*' ' + "OK to Save?"
197	mb = tkMessageBox.Message(title="Save Before Run or Check",
198	message=msg,
199	icon=tkMessageBox.QUESTION,
200	type=tkMessageBox.OKCANCEL,
201	default=tkMessageBox.OK,
202	master=self.editwin.text)
203	return mb.show()
204
205	def errorbox(self, title, message):
206	# XXX This should really be a function of EditorWindow...
207	tkMessageBox.showerror(title, message, master=self.editwin.text)
208	self.editwin.text.focus_set()