if _xpcom_:

_com_interfaces_ = [components.interfaces.koICodeIntelBuffer]

# Language-specific attributes that subclasses must fill-in.

lang = None # language name

caller = None # called by "on_modified" or by Command?

cpln_fillup_chars = "" # chars on which autocomplete UI will "fillup"

cpln_stop_chars = "" # chars on which autocomplete UI will stop

# Separator btwn completions in a completion list string for the

# Scintilla API.

# We don't use the default, ' ', because so of our languages have

# completions with spaces in them (e.g. Tcl).

scintilla_cpln_sep = '\n'

scintilla_cpln_sep_ord = ord(scintilla_cpln_sep)

# <prefix><stylename>, scintilla style constants prefix for this

# language. Most languages just have one prefix (e.g. "SCE_P_" for

# Python), but HTML, for example, has many.

sce_prefixes = None

# Code Browser control. (Note: most code browser control is on the

# relevant LangIntel).

#

# Show a row for this buffer even if empty of code browser data.

cb_show_if_empty = False

# Lazily built cache of SCE_* style number (per language) to constant

# name.

_style_name_from_style_num_from_lang = {}

def __init__(self, mgr, accessor, env=None, path=None, encoding=None, lang=None):

self.mgr = mgr

self.accessor = accessor # an Accessor instance

self._env = env

self.path = path if path is not None else "<Unsaved>"

self.encoding = encoding

self.last_citdl_expr = None

if lang is not None:

self.lang = lang

self.implicit_completion_skip_styles = dict(

(s, True) for s in self.comment_styles() + self.string_styles())

self.completion_skip_styles = dict(

(s, True) for s in self.number_styles())

def __repr__(self):

return "<%s buf '%s'>" % (self.lang,

basename(self.path) if self.path is not None else "(no file)")

@property

def env(self):

"""The runtime Environment instance for this buffer."""

return self._env or self.mgr.env

_langintel_cache = None

@property

def langintel(self):

if self._langintel_cache is None:

self._langintel_cache = self.mgr.langintel_from_lang(self.lang)

return self._langintel_cache

_langinfo_cache = None

@property

def langinfo(self):

if self._langinfo_cache is None:

self._langinfo_cache = self.mgr.lidb.langinfo_from_lang(self.lang)

return self._langinfo_cache

def lang_from_pos(self, pos):

return self.lang

def set_project(self, project):

if self.env:

self.env.set_project(project)

def trg_from_pos(self, pos, implicit=True):

"""If the given position is a _likely_ trigger point, return a

return self.langintel.trg_from_pos(self, pos, implicit)

def preceding_trg_from_pos(self, pos, curr_pos):

"""Look back from the given position for a trigger point within

return self.langintel.preceding_trg_from_pos(self, pos, curr_pos)

def async_eval_at_trg(self, trg, ctlr):

"""Asynchronously determine completion/calltip info for the given

# XXX xpcom UnwrapObject here?

self.langintel.async_eval_at_trg(self, trg, ctlr)

def cplns_from_trg(self, trg, timeout=None, ctlr=None):

"""Return completions for the given trigger point.

assert timeout is None or isinstance(timeout, (float, int)),\

"'timeout' must be None or a number"

if ctlr is None:

ctlr = EvalController()

self.async_eval_at_trg(trg, ctlr)

ctlr.wait(timeout)

if not ctlr.is_done():

ctlr.done("timed out")

ctlr.abort()

raise EvalTimeout("eval for %s timed-out" % trg)

return ctlr.cplns

def calltips_from_trg(self, trg, timeout=None, ctlr=None):

"""Return calltips for the given trigger point.

assert timeout is None or isinstance(timeout, (float, int)),\

"'timeout' must be None or a number"

if ctlr is None:

ctlr = EvalController()

self.async_eval_at_trg(trg, ctlr)

ctlr.wait(timeout)

if not ctlr.is_done():

ctlr.done("timed out")

ctlr.abort()

raise EvalTimeout("eval for %s timed-out" % trg)

return ctlr.calltips

def curr_calltip_arg_range(self, trg_pos, calltip, curr_pos, DEBUG=False):

"""Return that range in the calltip of the "current" arg.

return self.langintel.curr_calltip_arg_range(self, trg_pos, calltip,

curr_pos, DEBUG=DEBUG)

def text_chunks_from_lang(self, lang):

"""Generate a list of text chunks of the given language content.

yield 0, self.accessor.text

@property

def libs(self):

"""Return the ordered list libraries in which to search for blob

raise VirtualMethodError("Buffer subclass for lang '%s' should "

"implement the 'libs' property" % self.lang)

def to_html(self, include_styling=False, include_html=False, title=None,

do_trg=False, do_eval=False):

"""Return a styled HTML snippet for the current buffer.

from io import StringIO

html = StringIO()

if include_html:

html.write('''\

''' % title)

if include_styling:

html.write('''

''')

# XXX escape lang name for CSS class

html.write('<div class="code %s">\n' % self.lang.lower())

curr_udl_region = None

ch = last_ch = None

for token in self.accessor.gen_tokens():

css_classes = self.style_names_from_style_num(token["style"])

if css_classes and css_classes[0].startswith("SCE_UDL_"):

udl_region = css_classes[0].split('_')[2]

if udl_region == curr_udl_region:

pass

else:

if curr_udl_region:

html.write('\n</span>\n')

html.write('\n<span class="udl-region">\n')

curr_udl_region = udl_region

html.write('<span class="%s" onmouseover="show_class(event.target);">'

% ' '.join(css_classes))

for i, ch in enumerate(token["text"]):

if ch == "\n" and last_ch == "\r":

# Treat '\r\n' as one char.

continue

if do_trg:

try:

trg = self.trg_from_pos(token["start_index"] + i)

except CodeIntelError as ex:

html.write(self._html_from_trg_error(ex))

else:

if trg is not None:

html.write(self._html_from_trg(trg,

do_eval=do_eval))

# XXX Need to do tab expansion.

html.write(_htmlescape(ch, quote=True, whitespace=True))

last_ch = ch

html.write('</span>')

if curr_udl_region:

html.write('\n</span>\n')

html.write('</div>\n')

if include_html:

html.write('''

''')

return html.getvalue()

def _html_from_trg_error(self, ex):

marker = "&curren;"

classes = ["trg"]

classes.append("trg-error")

result = _htmlescape(traceback.format_exc(), whitespace=True)

info_html = '<div>%s</div' % result

return '<span class="%s">%s<span class="trg-info">%s</span></span>' \

% (' '.join(classes), marker, info_html)

def _html_from_trg(self, trg, do_eval=False):

marker = "&curren;"

classes = ["trg"]

try:

eval_log_stream = StringIO()

hdlr = logging.StreamHandler(eval_log_stream)

infoFmt = "%(name)s: %(message)s"

fmtr = logging.Formatter("%(name)s: %(levelname)s: %(message)s")

hdlr.setFormatter(fmtr)

codeintel_logger = logging.getLogger("codeintel")

codeintel_logger.addHandler(hdlr)

if do_eval:

ctlr = LogEvalController(codeintel_logger)

try:

if trg.form == TRG_FORM_CPLN:

cplns = self.cplns_from_trg(trg, ctlr=ctlr)

else:

calltips = self.calltips_from_trg(trg, ctlr=ctlr)

finally:

codeintel_logger.removeHandler(hdlr)

except NotATriggerError:

classes.append("trg-notatrg")

result = "(not a trigger point, false alarm by trg_from_pos())"

except (EvalError, NotImplementedError,

# XXX Eventually citdl evaluation shouldn't use

# codeintel2.CodeIntelError.

CodeIntelError) as ex:

classes.append("trg-evalerror")

result = _htmlescape(traceback.format_exc(), whitespace=True)

else:

if trg.form == TRG_FORM_CPLN:

if not do_eval:

classes.append("trg-noresults")

result = "(eval skipped)"

elif cplns:

result = "<br />".join(["<em>%s</em> %s" % c

for c in cplns])

else:

classes.append("trg-noresults")

result = "(no completions)"

else:

if not do_eval:

classes.append("trg-noresults")

result = "(eval skipped)"

elif calltips:

result = _htmlescape(calltips[0], whitespace=True)

else:

classes.append("trg-noresults")

result = "(no calltip)"

eval_log = _htmlescape(str(trg), whitespace=True)

eval_log += "<hr />"

eval_log += _htmlescape(eval_log_stream.getvalue(), whitespace=True)

info_html = ('<table><tr valign="top">'

'<td>%s</td>'

'<td class="trg-evallog">%s</td>'

'</tr></table>'

% (result, eval_log))

return '<span class="%s">%s<span class="trg-info">%s</span></span>' \

% (' '.join(classes), marker, info_html)

#---- Scintilla style helpers.

def style_names_from_style_num(self, style_num):

# XXX Would like to have python-foo instead of p_foo or SCE_P_FOO, but

# that requires a more comprehensive solution for all langs and

# multi-langs.

style_names = []

# Get the constant name from ScintillaConstants.

if self.lang not in self._style_name_from_style_num_from_lang:

name_from_num \

= self._style_name_from_style_num_from_lang[self.lang] = {}

sce_prefixes = self.sce_prefixes

if sce_prefixes is None:

# Try and guess the prefix then.

log.warn("Guessing sce_prefix as 'SCE_%s_' - if that's not "

"correct then define 'sce_prefixes' on your buffer"

"class", self.lang.upper())

sce_prefixes = ["SCE_%s_" % (self.lang.upper())]

for attr in dir(ScintillaConstants):

for sce_prefix in sce_prefixes:

if attr.startswith(sce_prefix):

name_from_num[getattr(ScintillaConstants, attr)] = attr

else:

name_from_num \

= self._style_name_from_style_num_from_lang[self.lang]

const_name = self._style_name_from_style_num_from_lang[

self.lang].get(style_num, "Unknown style")

style_names.append("%d - %s" % (style_num, const_name))

# Get a style group from styles.py.

if self.lang in styles.StateMap:

for style_group, const_names in list(styles.StateMap[self.lang].items()):

if const_name in const_names:

style_names.append(style_group)

break

else:

log.warn("lang '%s' not in styles.StateMap: won't have "

"common style groups in HTML output" % self.lang)

return style_names

__string_styles = None

def string_styles(self):

if self.__string_styles is None:

state_map = styles.StateMap[self.lang]

self.__string_styles = [

getattr(ScintillaConstants, style_name)

for style_class in ("strings", "stringeol")

for style_name in state_map.get(style_class, [])

]

return self.__string_styles

__comment_styles = None

def comment_styles(self):

if self.__comment_styles is None:

state_map = styles.StateMap[self.lang]

self.__comment_styles = [

getattr(ScintillaConstants, style_name)

for style_class in ("comments", "here documents",

"data sections")

for style_name in state_map.get(style_class, [])

]

return self.__comment_styles

__number_styles = None

def number_styles(self):

if self.__number_styles is None:

state_map = styles.StateMap[self.lang]

self.__number_styles = [

getattr(ScintillaConstants, style_name)

for style_class in ("numbers",)

for style_name in state_map.get(style_class, [])

]

"""A buffer for a language that is not explicitly registered as

def __init__(self, lang, mgr, accessor, env=None, path=None,

encoding=None):

self.lang = lang

Buffer.__init__(self, mgr, accessor, env=env, path=path,

encoding=encoding)

# TODO: Is there a need/use in possibly determining scintilla styles

# for this language?

def string_styles(self):

return []

def comment_styles(self):

return []

def number_styles(self):

"""Replace special characters '&', '<' and '>' by SGML entities.

s = s.replace("&", "&amp;") # Must be done first!

s = s.replace("<", "&lt;")

s = s.replace(">", "&gt;")

if quote:

s = s.replace('"', "&quot;")

if whitespace:

s = s.replace(' ', "&nbsp;")

# XXX Adding that '\n' might be controversial.

s = re.sub(r"(\r\n|\r|\n)", "<br />\n", s)