def async_fetch_commit_details(self, ids, visitor):
"""
Fetch the details for each of the commits in the list.
These details are returned asynchronously to GPS by calling
`visitor.set_details`.
:param List(str) ids: the list of commits for which we want the
details.
:param GPS.VCS2_Task_Visitor visitor: the object used to
report the details.
"""
GPS.Console().write("This action is not supported for %s" %
(self.name, ))
def on_spawn(self, filestr, project, recursive):
"""
Spawn gnatcheck.
Must be called only after we have set the rules file
"""
self.updateGnatCmd()
if self.checkCmd == "":
GPS.Console("Messages").write("Error: could not find gnatcheck")
return
# launch gnat check with specified project
cmd = [self.checkCmd,
'-P', project.file().name("Tools_Server"),
'-dd'] # progress
if self.gnatArgs:
cmd += self.gnatArgs
# also analyse subprojects ?
if recursive:
cmd.append('-U')
# define the scenario variables
scenario = GPS.Project.scenario_variables()
if scenario is not None:
for i, j in scenario.items():
cmd.append('-X%s=%s' % (i, j))
# now specify the files to check
cmd.append(filestr)
if self.rules_file:
cmd.extend(
['-rules', '-from=%s' % self.rules_file.name("Tools_Server")])
# clear the Checks category in the Locations view
if GPS.Locations.list_categories().count(self.locations_string) > 0:
GPS.Locations.remove_category(self.locations_string)
self.msg = ""
GPS.Process(
cmd, "^.+$",
on_match=self.on_match,
on_exit=self.on_exit,
progress_regexp="^ *completed (\d*) out of (\d*) .*$",
progress_current=1,
progress_total=2,
remote_server="Tools_Server",
show_command=True)
def align_arrows():
"""Aligns Ada arrow symbol '=>' in current selection"""
# The algorithm is the following:
# - indent the selection
# - for N 1 .. 9:
# - replace level Nth of => by a special tag @>
# - aling on the special tag @> replacing it with =>
buffer = GPS.EditorBuffer.get()
top = buffer.selection_start()
bottom = buffer.selection_end()
top.create_mark("top")
bottom.create_mark("bottom")
found = False
if top == bottom:
GPS.MDI.dialog("You must first select the intended text")
return
try:
with buffer.new_undo_group():
for lr in range(9):
try_indent(buffer, top, bottom)
top = buffer.get_mark("top").location()
bottom = buffer.get_mark("bottom").location()
chars = buffer.get_chars(top, bottom)
level = 0
for k in range(len(chars)):
if chars[k] == '(':
level = level + 1
elif chars[k] == ')':
level = level - 1
elif chars[k] == '\n':
found = False
elif k + 4 < len(chars) and chars[k:k + 4] == "case":
level = level + 1
elif k + 8 < len(chars) and chars[k:k + 8] == "end case":
level = level - 1
elif (level == lr and k + 2 < len(chars)
and chars[k:k + 2] == "=>" and not found):
chars = chars[:k] + "@>" + chars[k + 2:]
found = True
buffer.delete(top, bottom)
buffer.insert(top, chars)
top.create_mark("top")
bottom.create_mark("bottom")
top = buffer.get_mark("top").location()
bottom = buffer.get_mark("bottom").location()
range_align_on(top, bottom, sep="@>", replace_with=" => ")
top = buffer.get_mark("top").location()
bottom = buffer.get_mark("bottom").location()
buffer.select(top, bottom)
except:
GPS.Console().write(str(sys.exc_info()) + "\n")
def __verify_settings(self, for_debug=False):
"""
Verify that the settings have correctly been set in order to flash,
and, if for_debug is True, to debug a remote target.
Return True if the settings are correctly set, False otherwise.
"""
console = GPS.Console("Messages")
message_header = ("Can't debug on board:"
if for_debug else "Can't flash the board:")
result = True
if not self.__connection_tool:
console.write(("%s no connection tool specified. Please set the " %
(message_header)),
mode="error")
console.insert_link("IDE'Connection_Tool",
self.__open_remote_project_properties)
console.write(" project attribute\n", mode="error")
result = False
if self.__connection_tool == "openocd" and not self.__config_file:
console.write(("%s no configuration file specified. "
"Please set the " % (message_header)),
mode="error")
console.insert_link("IDE'Connection_Config_File",
self.__open_remote_project_properties)
console.write(" project attribute\n", mode="error")
result = False
if for_debug and not self.__remote_target:
console.write(("%s no remote target specified. Please set the " %
(message_header)),
mode="error")
console.insert_link("IDE'Protocol_Host",
self.__open_remote_project_properties)
console.write(" project attribute\n", mode="error")
result = False
if for_debug and not self.__remote_protocol:
console.write(("%s no remote protocol specified. Please set the " %
(message_header)),
mode="error")
console.insert_link("IDE'Communication_Protocol",
self.__open_remote_project_properties)
console.write(" project attribute\n", mode="error")
result = False
return result
def on_project_changed(self):
global attempted
CreatedDirs = False
created = []
try:
must_create = GPS.Preference("Auto-Create-Dirs").get()
except Exception:
must_create = True
if must_create:
prjs = GPS.Project.root().dependencies(True)
prjs.append(GPS.Project.root())
for i in prjs:
dirs = [
i.get_attribute_as_string("Exec_Dir"),
i.get_attribute_as_string("Library_Dir"),
i.get_attribute_as_string("Object_Dir"),
i.get_attribute_as_string("Library_Src_Dir"),
i.get_attribute_as_string("Library_ALI_Dir"),
i.get_attribute_as_string("Artifacts_Dir", "IDE"),
i.get_attribute_as_string("Documentation_Dir", "Documentation")
]
for j in dirs:
if i and i not in [".", "", " "]:
dir = os.path.join(os.path.dirname(i.file().path),
j).strip()
# Only attempt to create each directory once
if dir not in attempted:
if not os.path.exists(dir):
os.makedirs(dir)
attempted.append(dir)
created.append(dir)
CreatedDirs = True
if CreatedDirs:
GPS.Console("Messages").write("Created missing dirs\n")
GPS.Console("Messages").write(string.join(created, "\n"))
GPS.Console("Messages").write("\n")
GPS.Project.recompute()
def __init__(self,
command,
close_on_exit=True,
force=False,
ansi=False,
manage_prompt=True,
task_manager=False):
self.close_on_exit = close_on_exit
try:
GPS.Console.__init__(self,
command[0],
manage_prompt=manage_prompt,
on_input=self.on_input,
on_destroy=Console_Process.on_destroy,
on_resize=self.on_resize,
on_interrupt=Console_Process.on_interrupt,
on_completion=self.on_completion,
on_key=self.on_key,
ansi=ansi,
force=force,
save_desktop=self.save_desktop)
GPS.Process.__init__(
self,
command=command,
regexp='.+',
single_line_regexp=True, # For efficiency
strip_cr=not ansi, # if ANSI terminal, CR is irrelevant
task_manager=task_manager,
on_exit=self.on_exit,
on_match=self.on_output)
except Exception:
GPS.Console().write(str(sys.exc_info()[1]) + '\n')
try:
self.destroy()
self.kill()
except Exception:
pass
GPS.Console().write('Could not spawn: %s\n' % (' '.join(command)))
def run_gnatcov_wf(self, main_name):
# Build the project with GNATcov switches
p = promises.TargetWrapper("GNATcov Build Main")
r = yield p.wait_on_execute()
if r is not 0:
GPS.Console("Messages").write("Can't build the project with " +
"the GNATcov switches",
mode="error")
return
# Get the executable to analyze
exe = str(GPS.File(main_name).executable_path)
# Run GNATcov on it
p = promises.TargetWrapper("Run under GNATcov")
r = yield p.wait_on_execute(exe)
if r is not 0:
GPS.Console("Messages").write("GNATcov run failed ", mode="error")
return
# Generate and display the GNATcov Coverage Report
p = promises.TargetWrapper("Generate GNATcov Main Report")
r = yield p.wait_on_execute(exe)
def ada2wsdl(api):
toolexe = locate_exec_on_path("ada2wsdl")
if toolexe == "":
GPS.Console("Messages").write("Error: ada2wsdl tool not found.")
else:
ofile = os.path.splitext(api)[0] + '.wsdl'
idirs = []
proj = GPS.current_context().project()
for dir in proj.source_dirs():
idirs = idirs + ["-I", dir]
opts = GPS.Project.get_tool_switches_as_list (proj, "Ada2WSDL") \
+ ["-o", ofile] + idirs + [api]
fopts = " ".join(opts)
fopts = string.replace(fopts, "\\", "/")
Console_Process(ofile, toolexe, fopts)
def async_action_on_branch(self, visitor, action, category, id, text=''):
"""
React to a double-click action in the Branches view.
:param GPS.VCS2_Task_Visitor visitor: the object used to report
asynchronously.
If action is ACTION_TOOLTIP, use `visitor.tooltip`.
:param GPS.VCS2.Action action: the action to perform
:param str category: the upper-cased category, i.e. the first
parameter to `visitor.branches` in the call to `async_branches`.
:param str id: the id of the specific line that was selected.
:param str text: the new name, when action is ACTION_RENAME
"""
GPS.Console().write("This action is not supported for %s" %
(self.name, ))
def async_view_file(self, visitor, ref, file):
"""
Show the full contents of the file for the given revision.
:param GPS.VCS2_Task.Visitor visitor: the object used to
report the diff, via its 'file_computed` method.
:param str ref: the ref to which we want to compare. This is
typically the id of a commit (as returned from
`async_fetch_history`, although it can also be the name of a
branch, or "HEAD" to indicate the last commit done on the
current branch.
:param GPS.File file: the file for which we want a diff.
"""
GPS.Console().write("This action is not supported for %s" %
(self.name, ))
def run_test():
GPS.execute_action("open Outline")
# Select 'my_class.hh' directory in the Project view
GPS.MDI.get("Project").raise_window()
explorer = get_widget_by_name("Project Explorer Tree")
select_in_tree(explorer, column=1, key='my_class.hh')
yield timeout(300)
# Check the Outline view contents
explorer = get_widget_by_name("Outline View Tree")
GPS.Console().write(str(dump_tree_model(explorer.get_model(), 1)))
gps_assert(dump_tree_model(explorer.get_model(), 1),
expected,
"Wrong outline view for main.cpp")
def _internal_commit_staged_files(self, visitor, args):
"""
Execute the command `args` and pass all staged files.
:param List(str) args: the command and its arguments
"""
# Need to copy the list, since '_staged' will be changed below
files = list(self._staged)
p = ProcessWrapper(args + [f.path for f in files],
directory=self.working_dir.path)
(status, output) = yield p.wait_until_terminate()
if status:
GPS.Console().write("%s %s" % (" ".join(args), output))
else:
self.stage_or_unstage_files(files, stage=False)
visitor.success('Commit successful')
def run_gnatemu(args, in_console=True):
command = GNATemulator.generate_gnatemu_command(
GNATemulator.get_gnatemu_name(), args)
GPS.Console("Messages").write("Running in emulator: %s\n" %
(' '.join(command)))
# - We open GNATemu in a console by default.
# - If specified, we use the BuildTarget for running GNATemu instead.
# - Don't close the console when GNAtemu exits so we have time to see
# the results
# - GNATemu should be in the task manager
if in_console:
yield Console_Process(command=command, force=True,
close_on_exit=False, task_manager=True,
manage_prompt=False)
else:
builder = promises.TargetWrapper("Run GNATemulator")
yield builder.wait_on_execute(extra_args=args)
def run_test():
# Open a file that contains a Right To Left Override unicode
# character.
buf = GPS.EditorBuffer.get(GPS.File("main.adb"))
# Set the charset to UTF8
prop = Editor_Properties_Dialog()
yield prop.open_and_yield("")
charset = prop.get_character_set_entry()
while charset.get_active_text() != "Unicode UTF-8":
charset.set_active(charset.get_active() + 1)
yield prop.ok()
gps_assert(
"Warning: the file contains bidirectional" in GPS.Console().get_text(),
True,
"A warning for unicode bidirectional characters should be displayed")
def _setup(self):
"""
Internal version of setup
"""
self.__connect_hooks()
if not self.view_title:
self.view_title = self.__class__.__name__.replace("_", " ")
self.setup()
# Catch "gps_started" implementation in legacy or user-defined plugins
if hasattr(self, "gps_started"):
GPS.Console("Messages").write(
"warning: Python module '%s' defines class '%s' with a"
" method 'gps_started': this is no longer supported: instead,"
" you should override 'setup'\n." % (
self.__module__, self.__class__.__name__))
def test_driver():
GPS.execute_action("/Debug/Initialize/no main file")
yield wait_tasks(other_than=known_tasks)
GPS.Console("Messages").clear()
yield wait_for_mdi_child('Debugger Console')
debugger = GPS.Debugger.get()
debugger.send("-target-attach " + os.environ['TESTPID'])
e = debugger.get_executable()
GPS.execute_action("debug continue")
yield timeout(500)
text = debugger.get_console().get_text()
gps_assert("[program running]" in text, True,
"The program should have been run on 'debug continue'")
def copy_base_file_name():
"""
Copy the base name of the current file in the clipboard, so that it can be
pasted elsewhere.
"""
ctxt = GPS.current_context()
if ctxt.file():
f = ctxt.file().base_name()
else:
b = GPS.EditorBuffer.get(open=False)
if b:
f = b.file().base_name()
if not f:
GPS.Console().write("No file found\n")
else:
GPS.Clipboard.copy(f)
def __init__(self):
self.vc_time_pattern = re.compile(VC_PATTERN)
self.vc_dictionary = dict()
self.loc_list = list()
try:
proc = GPS.Process(command="gnatprove --list-categories")
result = proc.get_result()
for line in result.split("\n"):
description = line.split("-")
if len(description) == 3:
self.vc_dictionary[
description[0].strip()] = description[1].strip()
except:
GPS.Console(MESSAGES).write(
"spat.py: Could not retrieve list of categories.", "error")
def is_instrumentation_supported(self):
# Check if GNATcov and GPRbuild are recent enough (after the 21
# release)
for exe in 'gnatcov', 'gprbuild':
try:
version_major, version_minor = self.version(exe)
except Exception as e:
# Can happen with the GS testuite if we use a fake gnatcov exe
GPS.Console().write(str(e))
return False
if not (int(version_major) >= 22 or
(int(version_major) == 21 and version_minor[-1] != "w")):
GPS.Logger("GNATCOVERAGE").log("instrumentation mode not " +
"supported due to an older %s" %
exe)
return False
return True
def restore_run(self, run_timestamp):
run = self.runs[run_timestamp]
# Restore the files from the saved dir
src = self._save_dir(run)
dest = GPS.Project.root().artifacts_dir()
for f in glob.glob(os.path.join(src, '*')):
tgt = os.path.join(dest, os.path.basename(f))
if os.path.exists(tgt):
shutil.rmtree(tgt)
shutil.copytree(f, tgt)
# Clear the Messages view
GPS.Console("Messages").clear()
# Clear the locations
GPS.Locations.remove_category(run["category"])
parser = spark2014.GNATprove_Parser(None)
parser.on_stdout(run['output'], None)
parser.on_exit(0, None)
def load_json(file, diagramFactory=None, load_styles=None):
"""
Load the contents of the JSON file into the specified diagram. See the
GPS.Browsers documentation for more information on the format.
:param file: A file-like object, or a string, the name of the file
:return: an instance of JSON_Diagram_File
"""
try:
if isinstance(file, str):
file = open(file)
return GPS.Browsers.Diagram.load_json_data(json.load(file),
diagramFactory,
load_styles)
except Exception as e:
GPS.Console().write("Unexpected exception %s\n%s\n" %
(e, traceback.format_exc()))
def run_gnatemu(self, args):
sv = GPS.Project.scenario_variables()
var_args = ["-X%s=%s" % (k, v) for k, v in sv.items()] if sv else []
command = [self.get_gnatemu_name()]
proj = GPS.Project.root()
if proj:
command.append("-P%s" % proj.file().path)
command += var_args + args
GPS.Console("Messages").write("Running in emulator: %s" %
(' '.join(command)))
# - Open a console for each GNATemu run
# - Don't close the console when GNAtemu exits so we have time to see
# the results
# - GNATemu should be in the task manager
Console_Process(command=command,
force=True,
close_on_exit=False,
task_manager=True)
def async_action_on_branch(self, visitor, action, category, id, text=''):
if category == CAT_REVIEWS:
if id:
id = json.loads(id)
if action == GPS.VCS2.Actions.DOUBLE_CLICK and id:
import webbrowser
webbrowser.open(id['url'])
elif action == GPS.VCS2.Actions.TOOLTIP:
visitor.tooltip(
'\nDouble-click to open Gerrit on this change' +
('\nClick [+] to cherry-pick this review' if id else ''))
elif action == GPS.VCS2.Actions.ADD and id:
p = self.base._git(['review', '--cherrypick', id['number']])
status, _ = yield p.wait_until_terminate(show_if_error=True)
if status == 0:
GPS.Console().write(
"Applied to working directory: %s\n" % id['number'])
def get_prep_file(for_subprogram=False, reset=False):
"""Retreive the .prep file in the project"""
context = GPS.current_context()
local_file = context.file().path
file = context.file().name("Build_Server")
if context.project():
list_dir = context.project().object_dirs(False)
else:
list_dir = GPS.Project.root().object_dirs(False)
if list_dir:
objdir = list_dir[0]
else:
objdir = GPS.get_tmp_dir()
GPS.Console("Messages").write(
"Could not find an object directory for %s, reverting to %s" %
(file, objdir))
prep_file = os.path.join(objdir, os.path.basename(local_file)) + ".prep"
return local_file, prep_file
def cu_load_preference(num):
cu_regexp = GPS.Preference(
"Messages:Custom Highlighting " + str(num) + "/regexp")
cu_style = GPS.Preference(
"Messages:Custom Highlighting " + str(num) + "/variant")
if cu_regexp.get() == "":
return
style_value = cu_style.get().split('@')
try:
GPS.Console().create_link(regexp=cu_regexp.get(),
on_click=lambda x: None,
foreground=style_value[1],
background=style_value[2],
underline=False,
font=style_value[0])
except GPS.Exception:
return
def __close_editors_if_needed(keep=set()):
"""
If too many editors are opened, close one.
:param set keep: a set of files that should not be closed, even if
they are not pinned.
"""
opened = GPS.EditorBuffer.list()
toclose = len(opened) - maxeditors.get()
for ed in reversed(opened):
if toclose <= 0:
break
if (ed.file() not in keep and not ed.is_modified()
and not getattr(ed, 'pinned', False)):
GPS.Console().write('Automatically closing %s\n' % ed.file().path)
ed.close(force=False)
toclose -= 1
def run_gnatemu(self, args):
gnatemu = self.get_gnatemu_name()
proj = GPS.Project.root()
project_arg = "-P%s" % proj.file().path if proj else ""
var_args = GPS.Project.scenario_variables_cmd_line("-X")
if var_args:
command = [gnatemu, project_arg, var_args] + args
else:
command = [gnatemu, project_arg] + args
GPS.Console("Messages").write("Running in emulator: %s" %
(' '.join(command)))
# - Open a console for each GNATemu run
# - Don't close the console when GNAtemu exits so we have time to see
# the results
# - GNATemu should be in the task manager
Console_Process(command=command,
force=True,
close_on_exit=False,
task_manager=True)
def textmate_themes():
""" Find all themes installed in the color_themes directory
and return them as a list of dictionary objects.
"""
results = []
for file in glob.glob(
os.path.join(GPS.get_system_dir(), 'share', 'gps', 'color_themes',
'themes', '*', '*.tmTheme')):
try:
results.append(TextmateTheme(file).theme())
except Exception:
msg, _, tb = sys.exc_info()
tb = "\n".join(traceback.format_list(traceback.extract_tb(tb)))
GPS.Console("Messages").write(
"Exception when parsing theme file '%s':\n%s\n%s\n" %
(file, msg, str(tb)))
return results
def __activate():
context = GPS.contextual_context() or GPS.current_context()
entity = context.entity()
loc = context.location()
buf = GPS.EditorBuffer.get(loc.file())
location = buf.at(loc.line(), loc.column())
entity_name = entity.name()
length = len(entity_name)
# Go to the beginning of the entity, as needed by gnatfind
while not location.starts_word():
location = location.forward_word(-1)
entity_file = os.path.basename(loc.file().path)
entity_line = location.line()
entity_column = location.column()
source_dirs = GPS.Project.root().get_attribute_as_list("source_dirs")
object_dir = GPS.Project.root().get_attribute_as_string("object_dir")
# Create the gnatfind command line
command = (["gnatfind", "-r"] + ["-aI%s" % d for d in source_dirs] + [
"-aO", object_dir,
"%s:%s:%s:%s" %
(entity_name, entity_file.split('\\')[-1], entity_line, entity_column)
])
# Write the command line in the Messages window
GPS.Console().write(" ".join(command) + "\n")
# Launch the process
proc = GPS.Process(command, on_exit=__on_gnatfind_exit)
proc.query = "%s (%s:%s)" % (entity_name, entity_line, entity_column)
def kill(self):
""" Kill everything created during interactive theorem proving """
global itp_started
itp_started = False
a = GPS.Console(ITP_CONSOLE)
# Any closing destroying can fail so try are needed to avoid killing
# nothing when the first exiting function fail.
try:
a.destroy()
except Exception:
print("Cannot close console")
try:
windows = GPS.MDI.children()
for a in windows:
if PROOF_TASK == a.name(short=True):
a.close(force=True)
except Exception:
print("Cannot close proof_task")
try:
windows = GPS.MDI.children()
for a in windows:
if PROOF_TREE_SHORT == a.name(short=True):
a.close(force=True)
except Exception:
print("Cannot close tree")
try:
self.process.kill()
except BaseException: # This is caught somewhere else and hang
print("Cannot kill why3_server process")
try:
self.timeout.remove()
except Exception:
print("Cannot stop timeout")
try:
self.kill_menu()
except Exception:
print "Cannot remove transformations menu"
