def show_error_marks(view):
'''Adds error marks to view.'''
erase_error_marks(view)
if not get_setting("show_visual_error_marks", True):
return
fill_outlines = False
gutter_mark = 'dot'
outlines = {'warning': [], 'illegal': []}
fn = view.file_name()
markers = {'warning': get_setting("marker_warning_scope", "comment"),
'illegal': get_setting("marker_error_scope", "invalid")
}
for line in ERRORS[fn].keys():
outlines['illegal'].append(view.full_line(view.text_point(line, 0)))
for line in WARNINGS[fn].keys():
outlines['warning'].append(view.full_line(view.text_point(line, 0)))
for lint_type in outlines:
if outlines[lint_type]:
args = [
'sublimeclang-outlines-{0}'.format(lint_type),
outlines[lint_type],
markers[lint_type],
gutter_mark
]
if not fill_outlines:
args.append(sublime.DRAW_OUTLINED)
view.add_regions(*args)
def update_settings(self):
cmdline = get_setting("analyzer_commandline", ["clang", "--analyze", "-o", "-"])
opts = get_setting("options")
for setting in opts:
cmdline.append(setting)
self.cmdline = cmdline
self.extensions = get_setting("analyzer_extensions")
def get_opts(self, view, filename):
folder = os.path.dirname(filename)
if folder in self.compilation_database:
opts = list(self.compilation_database[folder])
else:
self.set_status('%s not in compilation database' % folder)
opts = get_path_setting("options", [], view)
if not get_setting("dont_prepend_clang_includes", False, view):
opts.insert(0, "-I%s/clang/include" % scriptpath)
if get_setting("add_language_option", True, view):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting("additional_language_options", {}, view)
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
self.debug_options = get_setting("debug_options", False)
self.index_parse_options = get_setting("index_parse_options", 13, view)
return opts
def update_settings(self):
cmdline = get_setting("analyzer_commandline", ["clang", "--analyze", "-o", "-"])
opts = get_setting("options")
for setting in opts:
cmdline.append(setting)
self.cmdline = cmdline
self.extensions = get_setting("analyzer_extensions")
def show_error_marks(view):
'''Adds error marks to view.'''
erase_error_marks(view)
if not get_setting("show_visual_error_marks", True):
return
fill_outlines = False
gutter_mark = 'dot'
outlines = {'warning': [], 'illegal': []}
fn = view.file_name().encode("utf-8")
markers = {'warning': get_setting("marker_warning_scope", "comment"),
'illegal': get_setting("marker_error_scope", "invalid")
}
for line in ERRORS[fn].keys():
outlines['illegal'].append(view.full_line(view.text_point(line, 0)))
for line in WARNINGS[fn].keys():
outlines['warning'].append(view.full_line(view.text_point(line, 0)))
for lint_type in outlines:
if outlines[lint_type]:
args = [
'sublimeclang-outlines-{0}'.format(lint_type),
outlines[lint_type],
markers[lint_type],
gutter_mark
]
if not fill_outlines:
args.append(sublime.DRAW_OUTLINED)
view.add_regions(*args)
def relevant_resolvers(domain=None, include_universal=None, include_popups=None, include_external=False, include_disabled=False, order_matters=False):
if include_external:
load_external_plugins()
if isinstance(domain, basestring):
domain = domain.lower()
if include_universal is None:
include_universal = common.get_setting('allow_universal') == "true"
if include_popups is None:
include_popups = common.get_setting('allow_popups') == "true"
if include_popups is False:
common.logger.log_debug('Resolvers that require popups have been disabled')
classes = ResolveUrl.__class__.__subclasses__(ResolveUrl) + ResolveUrl.__class__.__subclasses__(ResolveGeneric)
relevant = []
for resolver in classes:
if include_disabled or resolver._is_enabled():
if (include_universal or not resolver.isUniversal()) and (include_popups or not resolver.isPopup()):
if domain is None or ((domain and any(domain in res_domain.lower() for res_domain in resolver.domains)) or '*' in resolver.domains):
relevant.append(resolver)
if order_matters:
relevant.sort(key=lambda x: x._get_priority())
common.logger.log_debug('Relevant Resolvers: %s' % relevant)
return relevant
def load_settings(self):
translationunitcache.tuCache.clear()
self.dont_complete_startswith = get_setting("dont_complete_startswith", ["operator", "~"])
self.recompile_delay = get_setting("recompile_delay", 1000)
self.cache_on_load = get_setting("cache_on_load", True)
self.remove_on_close = get_setting("remove_on_close", True)
self.time_completions = get_setting("time_completions", False)
def load_settings(self):
translationunitcache.tuCache.clear()
self.dont_complete_startswith = get_setting("dont_complete_startswith",
['operator', '~'])
self.recompile_delay = get_setting("recompile_delay", 1000)
self.cache_on_load = get_setting("cache_on_load", True)
self.remove_on_close = get_setting("remove_on_close", True)
self.time_completions = get_setting("time_completions", False)
def __init__(self):
super(InitBase, self).__init__()
self.aws_names = get_setting(self.key, 'aws_names')
self.deploy_name = get_setting(self.key,
'deploy_name') or self.deploy_name
self.app_name = get_setting(self.key, 'app_name') or self.app_name
ec2_resource = EC2Resource(ec2_conn, self.aws_names)
self.private_ips, self.ids = ec2_resource.get_private_ips()
def open(self, window=None):
if window == None:
window = sublime.active_window()
if not self.is_visible(window):
self.view = window.get_output_panel("clang")
self.view.settings().set("result_file_regex", "^(.+):([0-9]+),([0-9]+)")
if get_setting("output_panel_use_syntax_file", False):
fileName = get_setting("output_panel_syntax_file", None)
if fileName is not None:
self.view.set_syntax_file(fileName)
self.flush()
window.run_command("show_panel", {"panel": "output.clang"})
def get_opts(self, view):
opts = get_setting("options")
if get_setting("add_language_option", True):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
self.index_parse_options = get_setting("index_parse_options", 13)
return opts
def open(self, window=None):
if window == None:
window = sublime.active_window()
if not self.is_visible(window):
self.view = window.get_output_panel("clang")
self.view.settings().set("result_file_regex", "^(.+):([0-9]+),([0-9]+)")
if get_setting("output_panel_use_syntax_file", False):
fileName = get_setting("output_panel_syntax_file", None)
if fileName is not None:
self.view.set_syntax_file(fileName)
self.flush()
window.run_command("show_panel", {"panel": "output.clang"})
def load_settings(self):
tuCache.clear()
oldSettings = sublime.load_settings("clang.sublime-settings")
if oldSettings.get("popup_delay") != None:
sublime.error_message(
"SublimeClang's configuration file name was changed from \
'clang.sublime-settings' to 'SublimeClang.sublime-settings'. \
Please move your settings over to this new file and delete \
the old one.")
if get_setting("popupDelay") != None:
sublime.error_message(
"SublimeClang changed the 'popupDelay' setting to \
'popup_delay, please edit your \
SublimeClang.sublime-settings to match this")
if get_setting("recompileDelay") != None:
sublime.error_message(
"SublimeClang changed the 'recompileDelay' setting to \
'recompile_delay, please edit your \
SublimeClang.sublime-settings to match this")
self.popup_delay = get_setting("popup_delay", 500)
self.dont_complete_startswith = get_setting("dont_complete_startswith",
['operator', '~'])
self.recompile_delay = get_setting("recompile_delay", 1000)
self.cache_on_load = get_setting("cache_on_load", True)
self.remove_on_close = get_setting("remove_on_close", True)
self.time_completions = get_setting("time_completions", False)
def load_settings(self):
tuCache.clear()
oldSettings = sublime.load_settings("clang.sublime-settings")
if oldSettings.get("popup_delay") != None:
sublime.error_message(
"SublimeClang's configuration file name was changed from \
'clang.sublime-settings' to 'SublimeClang.sublime-settings'. \
Please move your settings over to this new file and delete \
the old one.")
if get_setting("popupDelay") != None:
sublime.error_message(
"SublimeClang changed the 'popupDelay' setting to \
'popup_delay, please edit your \
SublimeClang.sublime-settings to match this")
if get_setting("recompileDelay") != None:
sublime.error_message(
"SublimeClang changed the 'recompileDelay' setting to \
'recompile_delay, please edit your \
SublimeClang.sublime-settings to match this")
self.popup_delay = get_setting("popup_delay", 500)
self.dont_complete_startswith = get_setting("dont_complete_startswith",
['operator', '~'])
self.recompile_delay = get_setting("recompile_delay", 1000)
self.cache_on_load = get_setting("cache_on_load", True)
self.remove_on_close = get_setting("remove_on_close", True)
self.time_completions = get_setting("time_completions", False)
def relevant_resolvers(domain=None,
include_universal=None,
include_external=False,
include_disabled=False,
order_matters=False):
if include_external:
load_external_plugins()
if isinstance(domain, basestring):
domain = domain.lower()
if include_universal is None:
include_universal = common.get_setting('allow_universal') == "true"
classes = UrlResolver.__class__.__subclasses__(UrlResolver)
relevant = []
for resolver in classes:
if include_disabled or resolver._is_enabled():
if include_universal or not resolver.isUniversal():
if domain is None or (
(domain and any(domain in res_domain.lower()
for res_domain in resolver.domains))
or '*' in resolver.domains):
relevant.append(resolver)
if order_matters:
relevant.sort(key=lambda x: x._get_priority())
common.log_utils.log_debug('Relevant Resolvers: %s' % (relevant))
return relevant
def get_opts(self, view):
opts = get_path_setting("options")
if get_setting("add_language_option", True):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting("additional_language_options", {})
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
self.index_parse_options = get_setting("index_parse_options", 13)
return opts
def update_regions(self, f, v):
regions = []
for range in self.ranges[f]:
start = range[0]
end = range[1]
regions.append(sublime.Region(v.text_point(start[0]-1, start[1]-1), v.text_point(end[0]-1, end[1])))
v.show(regions[0])
v.add_regions("clang.analyzer", regions, get_setting("marker_analyzer_scope", "invalid"), "", sublime.DRAW_OUTLINED)
def update_regions(self, f, v):
regions = []
for range in self.ranges[f]:
start = range[0]
end = range[1]
regions.append(sublime.Region(v.text_point(start[0]-1, start[1]-1), v.text_point(end[0]-1, end[1])))
v.show(regions[0])
v.add_regions("clang.analyzer", regions, get_setting("marker_analyzer_scope", "invalid"), "", sublime.DRAW_OUTLINED)
def get_opts(self, view):
opts = get_path_setting("options", [], view)
if get_setting("add_language_option", True, view):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting("additional_language_options", {}, view)
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
if get_setting("debug_options", False):
print "Will compile file %s with the following options:\n%s" % (view.file_name(), opts)
self.index_parse_options = get_setting("index_parse_options", 13, view)
return opts
def __init__(self):
workerthreadcount = get_setting("worker_threadcount", -1)
self.as_super = super(TranslationUnitCache, self)
self.as_super.__init__(workerthreadcount)
self.translationUnits = LockedVariable({})
self.parsingList = LockedVariable([])
self.busyList = LockedVariable([])
self.index_parse_options = 13
self.index = None
self.debug_options = False
def get_opts(self, view):
opts = get_path_setting("options", [], view)
if not get_setting("dont_prepend_clang_includes", False, view):
opts.insert(0, "-I%s/clang/include" % scriptpath)
if get_setting("add_language_option", True, view):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting("additional_language_options", {}, view)
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
self.debug_options = get_setting("debug_options", False)
self.index_parse_options = get_setting("index_parse_options", 13, view)
return opts
def __init__(self):
workerthreadcount = get_setting("worker_threadcount", -1)
self.as_super = super(TranslationUnitCache, self)
self.as_super.__init__(workerthreadcount)
self.translationUnits = LockedVariable({})
self.parsingList = LockedVariable([])
self.busyList = LockedVariable([])
self.index_parse_options = 13
self.index = None
self.debug_options = False
def is_supported_language(view):
if view.is_scratch() or not get_setting("enabled", True, view) or view.file_name() == None:
return False
language = get_language(view)
if language == None or (language != "c++" and
language != "c" and
language != "objc" and
language != "objc++"):
return False
return True
def recompile(self):
view = self.view
unsaved_files = []
if view.is_dirty() and get_setting("reparse_use_dirty_buffer", False, view):
unsaved_files.append((sencode(view.file_name()),
view.substr(Region(0, view.size()))))
if not translationunitcache.tuCache.reparse(view, sencode(view.file_name()), unsaved_files,
self.reparse_done):
# Already parsing so retry in a bit
self.restart_recompile_timer(1)
def get_translation_unit(view, filename=None, blocking=False):
if filename == None:
filename = view.file_name()
if get_setting("warm_up_in_separate_thread", True) and not blocking:
stat = warm_up_cache(view, filename)
if stat == TranslationUnitCache.STATUS_NOT_IN_CACHE:
return None
elif stat == TranslationUnitCache.STATUS_PARSING:
sublime.status_message("Hold your horses, cache still warming up")
return None
return tuCache.get_translation_unit(filename, tuCache.get_opts(view))
def get_translation_unit(view, filename=None, blocking=False):
if filename == None:
filename = view.file_name().encode("utf-8")
if get_setting("warm_up_in_separate_thread", True, view) and not blocking:
stat = warm_up_cache(view, filename)
if stat == translationunitcache.TranslationUnitCache.STATUS_NOT_IN_CACHE:
return None
elif stat == translationunitcache.TranslationUnitCache.STATUS_PARSING:
sublime.status_message("Hold your horses, cache still warming up")
return None
return translationunitcache.tuCache.get_translation_unit(filename, translationunitcache.tuCache.get_opts(view), translationunitcache.tuCache.get_opts_script(view))
def get_opts(self, view):
opts = get_path_setting("options", [], view)
if get_setting("add_language_option", True, view):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting(
"additional_language_options", {}, view)
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
if get_setting("debug_options", False):
print "Will compile file %s with the following options:\n%s" % (
view.file_name(), opts)
self.index_parse_options = get_setting("index_parse_options", 13, view)
return opts
def recompile(self):
view = self.view
unsaved_files = []
if view.is_dirty() and get_setting("reparse_use_dirty_buffer", False, view):
unsaved_files.append((view.file_name().encode("utf-8"),
view.substr(Region(0, view.size()))))
if not translationunitcache.tuCache.reparse(view, view.file_name().encode("utf-8"), unsaved_files,
self.reparse_done):
# Already parsing so retry in a bit
self.restart_recompile_timer(1)
def get_opts(self, view):
opts = get_path_setting("options", [], view)
if not get_setting("dont_prepend_clang_includes", False, view):
opts.insert(0, "-I%s/clang/include" % scriptpath)
if get_setting("add_language_option", True, view):
language = get_language(view)
if language == "objc":
opts.append("-ObjC")
elif language == "objc++":
opts.append("-ObjC++")
else:
opts.append("-x")
opts.append(language)
additional_language_options = get_setting(
"additional_language_options", {}, view)
if additional_language_options.has_key(language):
opts.extend(additional_language_options[language] or [])
self.debug_options = get_setting("debug_options", False)
self.index_parse_options = get_setting("index_parse_options", 13, view)
return opts
def on_selection_modified(self, view):
v = output_view.get_view()
if not v is None and view.id() == v.id():
region = v.full_line(v.sel()[0].a)
v.add_regions("clang.analyze.selection", [region], get_setting("marker_analyzer_output_panel_scope", "invalid"), "", sublime.DRAW_OUTLINED)
row, col = v.rowcol(v.sel()[0].a)
diag = analyzer.get_diagnostic_at_line(row)
self.prepare_ranges(diag.get_ranges(row), diag.files)
for f in self.ranges:
v = sublime.active_window().open_file(f, sublime.TRANSIENT)
if not v.is_loading():
self.update_regions(f, v)
def on_selection_modified(self, view):
v = output_view.get_view()
if not v is None and view.id() == v.id():
region = v.full_line(v.sel()[0].a)
v.add_regions("clang.analyze.selection", [region], get_setting("marker_analyzer_output_panel_scope", "invalid"), "", sublime.DRAW_OUTLINED)
row, col = v.rowcol(v.sel()[0].a)
diag = analyzer.get_diagnostic_at_line(row)
self.prepare_ranges(diag.get_ranges(row), diag.files)
for f in self.ranges:
v = sublime.active_window().open_file(f, sublime.TRANSIENT)
if not v.is_loading():
self.update_regions(f, v)
def on_close(self, view):
if not get_setting("pop_on_close", True):
return
# If the view we just closed was last in the navigation_stack,
# consider it "popped" from the stack
fn = view.file_name()
while True:
if len(navigation_stack) == 0 or \
not navigation_stack[
len(navigation_stack) - 1][1].startswith(fn):
break
navigation_stack.pop()
def relevant_resolvers(domain=None,
include_universal=None,
include_popups=None,
include_external=False,
include_disabled=False,
order_matters=False):
if include_external:
load_external_plugins()
if isinstance(domain, basestring):
domain = domain.lower()
if include_universal is None:
include_universal = common.get_setting('allow_universal') == "true"
if include_popups is None:
include_popups = common.get_setting('allow_popups') == "true"
if include_popups is False:
common.logger.log_debug(
'Resolvers that require popups have been disabled')
classes = ResolveUrl.__class__.__subclasses__(
ResolveUrl) + ResolveUrl.__class__.__subclasses__(ResolveGeneric)
relevant = []
for resolver in classes:
relevant.append(resolver)
if include_disabled or resolver._is_enabled():
if (include_universal or not resolver.isUniversal()) and (
include_popups or not resolver.isPopup()):
if domain is None or (
(domain and any(domain in res_domain.lower()
for res_domain in resolver.domains))
or '*' in resolver.domains):
relevant.append(resolver)
if order_matters:
relevant.sort(key=lambda x: x._get_priority())
common.logger.log_debug('Relevant Resolvers: %s' % relevant)
return relevant
def highlight_panel_row(self):
if self.view is None:
return
view = sublime.active_window().active_view()
row, col = view.rowcol(view.sel()[0].a)
str = "%s:%d" % (view.file_name(), (row + 1))
r = self.view.find(str.replace('\\','\\\\'), 0)
panel_marker = get_setting("marker_output_panel_scope", "invalid")
if r == None:
self.view.erase_regions('highlightText')
else:
regions = [self.view.full_line(r)]
self.view.add_regions('highlightText', regions, panel_marker, 'dot', sublime.DRAW_OUTLINED)
def on_query_context(self, view, key, operator, operand, match_all):
if key == "clang_supported_language":
if view == None:
view = sublime.active_window().active_view()
return is_supported_language(view)
elif key == "clang_is_code":
return self.not_code_regex.search(view.scope_name(view.sel()[0].begin())) == None
elif key == "clang_complete_enabled":
return clang_complete_enabled
elif key == "clang_automatic_completion_popup":
return get_setting("automatic_completion_popup", True, view)
elif key == "clang_panel_visible":
return clang_error_panel.is_visible()
def run(self, **args):
show = args["show"] if "show" in args else None
aview = sublime.active_window().active_view()
error_marks = get_setting("error_marks_on_panel_only", False, aview)
if show or (show == None and not clang_error_panel.is_visible(self.window)):
clang_error_panel.open(self.window)
if error_marks:
show_error_marks(aview)
else:
clang_error_panel.close()
if error_marks:
erase_error_marks(aview)
def on_query_context(self, view, key, operator, operand, match_all):
if key == "clang_supported_language":
if view == None:
view = sublime.active_window().active_view()
return is_supported_language(view)
elif key == "clang_is_code":
return self.not_code_regex.search(view.scope_name(view.sel()[0].begin())) == None
elif key == "clang_complete_enabled":
return clang_complete_enabled
elif key == "clang_automatic_completion_popup":
return get_setting("automatic_completion_popup", True, view)
elif key == "clang_panel_visible":
return clang_error_panel.is_visible()
def run(self, **args):
show = args["show"] if "show" in args else None
aview = sublime.active_window().active_view()
error_marks = get_setting("error_marks_on_panel_only", False, aview)
if show or (show == None and not clang_error_panel.is_visible(self.window)):
clang_error_panel.open(self.window)
if error_marks:
show_error_marks(aview)
else:
clang_error_panel.close()
if error_marks:
erase_error_marks(aview)
def highlight_panel_row(self):
if self.view is None:
return
view = sublime.active_window().active_view()
row, col = view.rowcol(view.sel()[0].a)
str = "%s:%d" % (view.file_name(), (row + 1))
r = self.view.find(str.replace('\\','\\\\'), 0)
panel_marker = get_setting("marker_output_panel_scope", "invalid")
if r == None:
self.view.erase_regions('highlightText')
else:
regions = [self.view.full_line(r)]
self.view.add_regions('highlightText', regions, panel_marker, 'dot', sublime.DRAW_OUTLINED)
def highlight_panel_row():
if clang_view is None:
return
v = clang_view
view = sublime.active_window().active_view()
row, col = view.rowcol(view.sel()[0].a)
str = "%s:%d" % (view.file_name(), (row + 1))
r = v.find(str, 0)
panel_marker = get_setting("marker_output_panel_scope", "invalid")
if r == None:
v.erase_regions('highlightText')
else:
regions = [v.full_line(r)]
v.add_regions('highlightText', regions, panel_marker, 'dot', sublime.DRAW_OUTLINED)
def on_close(self, view):
if not get_setting("pop_on_close", True, view):
return
# If the view we just closed was last in the navigation_stack,
# consider it "popped" from the stack
fn = view.file_name()
if fn == None:
return
while True:
if len(navigation_stack) == 0 or \
not navigation_stack[
len(navigation_stack) - 1][1].startswith(fn):
break
navigation_stack.pop()
def is_supported_language(view):
if view.is_scratch() or not get_setting("enabled", True,
view) or view.file_name() == None:
return False
language = get_language(view)
# Exlcude CUDA files
excluded_file_type = file_exclusion_regex.search(view.file_name())
if excluded_file_type != None:
return False
if language == None or (language != "c++" and language != "c"
and language != "objc" and language != "objc++"):
return False
return True
def is_supported_language(view):
if view.is_scratch() or not get_setting("enabled", True, view) or view.file_name() == None:
return False
language = get_language(view)
# Exlcude CUDA files
excluded_file_type = file_exclusion_regex.search(view.file_name())
if excluded_file_type != None:
return False
if language == None or (language != "c++" and
language != "c" and
language != "objc" and
language != "objc++"):
return False
return True
def parse_database(self, on_done=None):
ret = False
self.compilation_database = {}
filename = expand_path(get_setting("compilation_database", None), None)
if filename is not None:
pl = self.parsingList.lock()
try:
if filename not in pl:
ret = True
pl.append(filename)
self.tasks.put((
self.task_parse_database,
(filename, on_done)))
finally:
self.parsingList.unlock()
return ret
def relevant_resolvers(domain=None, include_universal=None, include_external=False, include_disabled=False, order_matters=False):
if include_external:
load_external_plugins()
if include_universal is None:
include_universal = common.get_setting('allow_universal') == "true"
classes = UrlResolver.__class__.__subclasses__(UrlResolver)
relevant = []
for resolver in classes:
if include_disabled or resolver._is_enabled():
if include_universal or not resolver.isUniversal():
if domain is None or (any(domain in res_domain for res_domain in resolver.domains) or '*' in resolver.domains):
relevant.append(resolver)
if order_matters:
relevant.sort(key=lambda x: x._get_priority())
common.log_utils.log_debug('Relevant Resolvers: %s' % (relevant))
return relevant
def relevant_resolvers(domain=None,
include_universal=None,
include_external=False,
include_disabled=False,
include_xxx=False,
order_matters=False):
xxx_plugins_path = 'special://home/addons/script.module.urlresolver.xxx/resources/plugins/'
if include_xxx and xbmcvfs.exists(xxx_plugins_path):
__load_plugin_dir(xbmc.translatePath(xxx_plugins_path))
if include_external:
load_external_plugins()
if isinstance(domain, basestring):
domain = domain.lower()
if include_universal is None:
include_universal = common.get_setting('allow_universal') == "true"
classes = UrlResolver.__class__.__subclasses__(
UrlResolver) + UrlResolver.__class__.__subclasses__(GenericResolver)
relevant = []
for resolver in classes:
if include_disabled or resolver._is_enabled():
if include_universal or not resolver.isUniversal():
if domain is None or (
(domain and any(domain in res_domain.lower()
for res_domain in resolver.domains))
or '*' in resolver.domains):
relevant.append(resolver)
if order_matters:
relevant.sort(key=lambda x: x._get_priority())
common.logger.log_debug('Relevant Resolvers: %s' % (relevant))
return relevant
def get_opts_script(self, view):
return expand_path(get_setting("options_script", None, view), view.window())
def on_post_save(self, view):
if self.is_supported_language(view) and get_setting("reparse_on_save"):
self.view = view
self.recompile()
def display_status(self):
if get_setting("parse_status_messages", True):
self.as_super.display_status()
def display_compilation_results(view):
tu = get_translation_unit(view)
errString = ""
show = False
clear_error_marks() # clear visual error marks
erase_error_marks(view)
if tu == None:
return
tu.lock()
errorCount = 0
warningCount = 0
try:
if len(tu.var.diagnostics):
errString = ""
for diag in tu.var.diagnostics:
f = diag.location
filename = ""
if f.file != None:
filename = f.file.name
err = "%s:%d,%d - %s - %s" % (filename, f.line, f.column,
diag.severityName,
diag.spelling)
if diag.severity == cindex.Diagnostic.Fatal and \
"not found" in diag.spelling:
err = "%s\nDid you configure the include path used by clang properly?\n" \
"See http://github.com/quarnster/SublimeClang for more details on "\
"how to configure SublimeClang." % (err)
errString = "%s%s\n" % (errString, err)
if diag.severity == cindex.Diagnostic.Warning:
warningCount += 1
elif diag.severity >= cindex.Diagnostic.Error:
errorCount += 1
"""
for range in diag.ranges:
errString = "%s%s\n" % (errString, range)
for fix in diag.fixits:
errString = "%s%s\n" % (errString, fix)
"""
add_error_mark(
diag.severityName, filename, f.line - 1, diag.spelling)
show = get_setting("show_output_panel", True)
finally:
tu.unlock()
if (errorCount > 0 or warningCount > 0) and get_setting("show_status"):
statusString = "Clang Status: "
if errorCount > 0:
statusString = "%s%d Error%s" % (statusString, errorCount, "s" if errorCount != 1 else "")
if warningCount > 0:
statusString = "%s%s%d Warning%s" % (statusString, ", " if errorCount > 0 else "",
warningCount, "s" if warningCount != 1 else "")
view.set_status("SublimeClang", statusString)
else:
view.erase_status("SublimeClang")
window = view.window()
if not window is None:
v = view.window().get_output_panel("clang")
v.settings().set("result_file_regex", "^(.+):([0-9]+),([0-9]+)")
view.window().get_output_panel("clang")
set_clang_view(v)
v.set_read_only(False)
v.set_scratch(True)
v.set_name("sublimeclang.%s" % view.file_name())
e = v.begin_edit()
v.insert(e, 0, errString)
v.end_edit(e)
v.set_read_only(True)
show_error_marks(view)
update_statusbar(view)
if show:
view.window().run_command("show_panel", {"panel": "output.clang"})
elif get_setting("hide_output_when_empty", False):
view.window().run_command("hide_panel", {"panel": "output.clang"})
def on_activated(self, view):
if self.is_supported_language(view) and get_setting("reparse_on_activated"):
self.view = view
self.recompile()
def display_status(self):
if get_setting("analyzer_status_messages", True):
super(Analyzer, self).display_status()
def display_status(self):
if get_setting("parse_status_messages", True):
self.as_super.display_status()
def display_compilation_results(view):
tu = get_translation_unit(view)
errString = ""
show = False
clear_error_marks() # clear visual error marks
erase_error_marks(view)
if tu == None:
return
if not tu.try_lock():
return
try:
errorCount = 0
warningCount = 0
ignoreDirs = [
os.path.abspath(os.path.normpath(os.path.normcase(d)))
for d in get_setting("diagnostic_ignore_dirs", [], view)
]
ignore_regex_str = get_setting("diagnostic_ignore_regex",
"pragma once in main file")
if ignore_regex_str:
ignore_regex = re.compile(ignore_regex_str)
else:
ignore_regex = None
if len(tu.var.diagnostics):
errString = ""
for diag in tu.var.diagnostics:
f = diag.location
filename = ""
if f.file != None:
filename = f.file.name
if ignore_diagnostic(filename, ignoreDirs):
continue
err = "%s:%d,%d - %s - %s" % (filename, f.line, f.column,
diag.severityName, diag.spelling)
if ignore_regex and ignore_regex.search(err):
continue
try:
if len(diag.disable_option) > 0:
err = "%s [Disable with %s]" % (err,
diag.disable_option)
except AttributeError:
pass
if diag.severity == cindex.Diagnostic.Fatal and \
"not found" in diag.spelling:
err = "%s\nDid you configure the include path used by clang properly?\n" \
"See http://github.com/quarnster/SublimeClang for more details on "\
"how to configure SublimeClang." % (err)
errString = "%s%s\n" % (errString, err)
if diag.severity == cindex.Diagnostic.Warning:
warningCount += 1
elif diag.severity >= cindex.Diagnostic.Error:
errorCount += 1
"""
for range in diag.ranges:
errString = "%s%s\n" % (errString, range)
for fix in diag.fixits:
errString = "%s%s\n" % (errString, fix)
"""
add_error_mark(diag.severityName, filename, f.line - 1,
diag.spelling)
show = errString and get_setting("show_output_panel", True, view)
finally:
tu.unlock()
if (errorCount > 0 or warningCount > 0) and get_setting(
"show_status", True, view):
statusString = "Clang Status: "
if errorCount > 0:
statusString = "%s%d Error%s" % (statusString, errorCount,
"s" if errorCount != 1 else "")
if warningCount > 0:
statusString = "%s%s%d Warning%s" % (
statusString, ", " if errorCount > 0 else "", warningCount,
"s" if warningCount != 1 else "")
view.set_status("SublimeClang", statusString)
else:
view.erase_status("SublimeClang")
window = view.window()
clang_error_panel.set_data(errString)
update_statusbar(view)
if not get_setting("error_marks_on_panel_only", False, view):
show_error_marks(view)
if not window is None:
if show:
window.run_command("clang_toggle_panel", {"show": True})
elif get_setting("hide_output_when_empty", False, view):
if clang_error_panel.is_visible():
window.run_command("clang_toggle_panel", {"show": False})
def display_compilation_results(view):
tu = get_translation_unit(view)
errString = ""
show = False
clear_error_marks() # clear visual error marks
erase_error_marks(view)
if tu == None:
return
tu.lock()
errorCount = 0
warningCount = 0
try:
if len(tu.var.diagnostics):
errString = ""
for diag in tu.var.diagnostics:
f = diag.location
filename = ""
if f.file != None:
filename = f.file.name
err = "%s:%d,%d - %s - %s" % (filename, f.line, f.column,
diag.severityName, diag.spelling)
try:
if len(diag.disable_option) > 0:
err = "%s [Disable with %s]" % (err,
diag.disable_option)
except AttributeError:
pass
if diag.severity == cindex.Diagnostic.Fatal and \
"not found" in diag.spelling:
err = "%s\nDid you configure the include path used by clang properly?\n" \
"See http://github.com/quarnster/SublimeClang for more details on "\
"how to configure SublimeClang." % (err)
errString = "%s%s\n" % (errString, err)
if diag.severity == cindex.Diagnostic.Warning:
warningCount += 1
elif diag.severity >= cindex.Diagnostic.Error:
errorCount += 1
"""
for range in diag.ranges:
errString = "%s%s\n" % (errString, range)
for fix in diag.fixits:
errString = "%s%s\n" % (errString, fix)
"""
add_error_mark(diag.severityName, filename, f.line - 1,
diag.spelling)
show = get_setting("show_output_panel", True, view)
finally:
tu.unlock()
if (errorCount > 0 or warningCount > 0) and get_setting(
"show_status", True, view):
statusString = "Clang Status: "
if errorCount > 0:
statusString = "%s%d Error%s" % (statusString, errorCount,
"s" if errorCount != 1 else "")
if warningCount > 0:
statusString = "%s%s%d Warning%s" % (
statusString, ", " if errorCount > 0 else "", warningCount,
"s" if warningCount != 1 else "")
view.set_status("SublimeClang", statusString)
else:
view.erase_status("SublimeClang")
window = view.window()
output_view = None
if not window is None:
v = view.window().get_output_panel("clang")
v.settings().set("result_file_regex", "^(.+):([0-9]+),([0-9]+)")
view.window().get_output_panel("clang")
set_clang_view(v)
v.set_read_only(False)
v.set_scratch(True)
v.set_name("sublimeclang.%s" % view.file_name())
e = v.begin_edit()
v.insert(e, 0, errString)
v.end_edit(e)
v.set_read_only(True)
output_view = v
show_error_marks(view)
update_statusbar(view)
if not window is None:
if show:
window.run_command("show_panel", {"panel": "output.clang"})
elif get_setting("hide_output_when_empty", False, view):
if not output_view is None and output_view.window() != None:
window.run_command("hide_panel", {"panel": "output.clang"})
def return_completions(self, comp, view):
if get_setting("inhibit_sublime_completions", True, view):
return (comp, sublime.INHIBIT_WORD_COMPLETIONS
| sublime.INHIBIT_EXPLICIT_COMPLETIONS)
return comp
def on_query_completions(self, view, prefix, locations):
global clang_complete_enabled
if not is_supported_language(view) or not clang_complete_enabled or \
not view.match_selector(locations[0], '-string -comment -constant'):
return []
line = view.substr(
sublime.Region(view.line(locations[0]).begin(), locations[0]))
match = re.search(r"[,\s]*(\w+)\s+\w+$", line)
if match != None:
valid = [
"new", "delete", "return", "goto", "case", "const", "static",
"class", "struct", "typedef", "union"
]
if match.group(1) not in valid:
# Probably a variable or function declaration
# There's no point in trying to complete
# a name that hasn't been typed yet...
return self.return_completions([], view)
timing = ""
tot = 0
start = time.time()
tu = get_translation_unit(view)
if tu == None:
return self.return_completions([], view)
ret = None
tu.lock()
try:
if self.time_completions:
curr = (time.time() - start) * 1000
tot += curr
timing += "TU: %f" % (curr)
start = time.time()
cached_results = None
if clang_fast_completions and get_setting(
"enable_fast_completions", True, view):
data = view.substr(sublime.Region(0, locations[0]))
try:
cached_results = tu.cache.complete(data, prefix)
except:
traceback.print_exc()
if cached_results != None:
print "found fast completions"
ret = cached_results
else:
print "doing slow completions"
row, col = view.rowcol(locations[0] - len(prefix))
unsaved_files = []
if view.is_dirty():
unsaved_files.append((view.file_name().encode("utf-8"),
view.substr(Region(0, view.size()))))
ret = tu.cache.clangcomplete(
view.file_name().encode("utf-8"), row + 1, col + 1,
unsaved_files,
is_member_completion(view, locations[0] - len(prefix)))
if self.time_completions:
curr = (time.time() - start) * 1000
tot += curr
timing += ", Comp: %f" % (curr)
start = time.time()
if len(self.dont_complete_startswith) and ret:
i = 0
while i < len(ret):
disp = ret[i][0]
pop = False
for comp in self.dont_complete_startswith:
if disp.startswith(comp):
pop = True
break
if pop:
ret.pop(i)
else:
i += 1
if self.time_completions:
curr = (time.time() - start) * 1000
tot += curr
timing += ", Filter: %f" % (curr)
timing += ", Tot: %f ms" % (tot)
print timing
sublime.status_message(timing)
finally:
tu.unlock()
if not ret is None:
return self.return_completions(ret, view)
return self.return_completions([], view)
def on_post_save(self, view):
if is_supported_language(view) and get_setting("reparse_on_save", True,
view):
self.view = view
self.restart_recompile_timer(0.1)
def get_opts_script(self, view):
return expand_path(get_setting("options_script", "", view),
view.window())
def __init__(self):
self.aws_names = get_setting(self.key, 'aws_names')
ec2_resource = EC2Resource(ec2_conn, self.aws_names)
self.private_ips, self.ids = ec2_resource.get_private_ips()
