class koVisualBasicLanguage(KoCommonBasicLanguageService): name = "VisualBasic" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{7B83199C-6C30-43ef-9087-329831FC6425}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".vb" commentDelimiterInfo = { "line": [ "'", "rem ", "REM " ], } # Problems: 'private' and 'public' and 'shared' can come before a function name. def __init__(self): KoCommonBasicLanguageService.__init__(self) del self.matchingSoftChars["'"] def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_VB) self._lexer.setKeywords(0, keywords) self._lexer.supportsFolding = 0 return self._lexer
class koVisualBasicLanguage(KoCommonBasicLanguageService): name = "VisualBasic" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{7B83199C-6C30-43ef-9087-329831FC6425}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".vb" commentDelimiterInfo = { "line": ["'", "rem ", "REM "], } # Problems: 'private' and 'public' and 'shared' can come before a function name. def __init__(self): KoCommonBasicLanguageService.__init__(self) del self.matchingSoftChars["'"] def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_VB) self._lexer.setKeywords(0, keywords) self._lexer.supportsFolding = 0 return self._lexer
class koMatlabLanguage(KoLanguageKeywordBase): name = "Matlab" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{913BAE69-8E17-4c91-B855-687F0A34CFF6}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".m.matlab" extraFileAssociations = ['*.m', '*.matlab'] commentDelimiterInfo = { "line": [ "%", "#" ] } supportsSmartIndent = "keyword" # See comment in koLuaLanguage.py for why some keywords are in both # _indenting_statements and _keyword_dedenting_keywords _indenting_statements = ['function', 'if', 'for', 'parfor', 'while', 'else', 'do', 'elseif', 'switch', 'case', 'otherwise'] _dedenting_statements = ['break', 'continue', 'return', 'error'] _keyword_dedenting_keywords = ['end', 'else', 'elseif', 'case', 'otherwise', 'until'] _keywords = """break case catch classdef continue else elseif end error for function global if otherwise parfor persistent return spmd switch try while""".split() sciLexer = components.interfaces.ISciMoz.SCLEX_MATLAB def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_MATLAB_COMMENT,], _indent_styles = [sci_constants.SCE_MATLAB_OPERATOR], _variable_styles = [sci_constants.SCE_MATLAB_IDENTIFIER], _lineup_close_styles = [sci_constants.SCE_MATLAB_OPERATOR], _lineup_styles = [sci_constants.SCE_MATLAB_OPERATOR], _keyword_styles = [sci_constants.SCE_MATLAB_KEYWORD], _default_styles = [sci_constants.SCE_MATLAB_DEFAULT], _ignorable_styles = [sci_constants.SCE_MATLAB_COMMENT, sci_constants.SCE_MATLAB_NUMBER], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(self.sciLexer) self._lexer.setKeywords(0, self._keywords) self._lexer.supportsFolding = 1 return self._lexer # matches: # function [output] = name(input) # classdef name < super # %% cell title namedBlockDescription = 'Matlab functions and classes' namedBlockRE = r'(?:\b(?:function|classdef)\s+\w+|^\s*%%\s+\w+.*)' searchURL = "http://www.mathworks.com/help/search/doc/en/?qdoc=%W" sample = r"""function b = acyclic(adj_mat, directed)
class koErlangLanguage(KoLanguageBase): name = "Erlang" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{0153c47a-f668-41d4-8519-9ecd6b1c5ba0}" _reg_categories_ = [("komodo-language", name)] _stateMap = { "default": ("SCE_ERLANG_DEFAULT",), "comments": ( "SCE_ERLANG_COMMENT", "SCE_ERLANG_COMMENT_FUNCTION", "SCE_ERLANG_COMMENT_MODULE", "SCE_ERLANG_COMMENT_DOC", "SCE_ERLANG_COMMENT_DOC_MACRO", ), "variables": ("SCE_ERLANG_VARIABLE",), "numbers": ("SCE_ERLANG_NUMBER",), "keywords": ("SCE_ERLANG_KEYWORD",), "strings": ("SCE_ERLANG_STRING", "SCE_ERLANG_CHARACTER"), "operators": ("SCE_ERLANG_OPERATOR",), "functions": ("SCE_ERLANG_FUNCTION_NAME",), "macros": ("SCE_ERLANG_MACRO",), "records": ("SCE_ERLANG_RECORD",), "atoms": ("SCE_ERLANG_ATOM",), "nodes": ("SCE_ERLANG_NODE_NAME",), "unknown": ("SCE_ERLANG_UNKNOWN",), } defaultExtension = ".erl" commentDelimiterInfo = {"line": ["%"]} sample = """-module(test). -export([fac/1]). fac(0) -> 1; fac(N) -> N * fac(N-1). """ def __init__(self): KoLanguageBase.__init__(self) self._fastCharData = ErlangFastCharData( trigger_char=".", style_list=(sci_constants.SCE_ERLANG_OPERATOR,), skippable_chars_by_style={sci_constants.SCE_ERLANG_OPERATOR: "])"}, ) _keywords = """ after begin case catch cond end fun if let of query receive when define record export import include include_lib ifdef ifndef else endif undef apply attribute call do in letrec module primop try""".split() def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_ERLANG) self._lexer.setKeywords(0, self._keywords) return self._lexer
class koPowerBasicLanguage(KoCommonBasicLanguageService): name = "PowerBasic" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{0bc5c569-6546-45ec-8452-4636d326e0f7}" _reg_categories_ = [("komodo-language", name)] _stateMap = { 'default': ('SCE_B_DEFAULT', ), 'keywords': ('SCE_B_KEYWORD', 'SCE_B_KEYWORD2', 'SCE_B_KEYWORD3', 'SCE_B_KEYWORD4'), 'identifiers': ('SCE_B_IDENTIFIER', ), 'comments': ('SCE_B_COMMENT', ), 'numbers': ('SCE_B_NUMBER', ), 'strings': ('SCE_B_STRING', ), 'stringeol': ('SCE_B_STRINGEOL', ), 'operators': ('SCE_B_OPERATOR', ), 'preprocessor': ('SCE_B_PREPROCESSOR', ), 'date': ('SCE_B_DATE', ), 'constants': ('SCE_B_CONSTANT', ), 'assembly': ('SCE_B_ASM', ), } defaultExtension = '.pb' commentDelimiterInfo = {"line": ["rem ", "REM "]} sample = """ INPUT "What is your name"; UserName$ PRINT "Hello "; UserName$ DO INPUT "How many stars do you want"; NumStars Stars$ = "" Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC --or-- Stars$ = STRING$(NumStars, "*") ' <- MS BASIC PRINT Stars$ DO INPUT "Do you want more stars"; Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1); LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Goodbye "; FOR I = 1 TO 200 PRINT UserName$; " "; NEXT I PRINT """ def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer( components.interfaces.ISciMoz.SCLEX_POWERBASIC) self._lexer.setKeywords(0, self._keywords_preprocessor + \ self._keywords_functions + \ self._keywords_proceedures + \ self._keywords_datatypes + \ self._keywords_options) self._lexer.supportsFolding = 1 return self._lexer _keywords_preprocessor = """$alias $code $com $compile $cpu $debug $dim $dynamic $endif $error $event $float $huge $if $include $inline $lib $link $optimize $option $segment $sound $stack $static $string all array cga chain cntlbreak com ega emulate exe fullfloat graph herc iprint lpt map memory none npx off path pbdebug procedure signed size speed unit unsigned vga""".split() _keywords_functions = """absolute access and any append array as asc ascend ascii asm at atn attrib base beep bin$ binary bit bits bload bsave call case cbcd cbyt cdbl cdwd ceil cext cfix chain chdir chdrive chr$ cint circle clear clng close cls codeptr codeseg collate color com command$ common cos cqud csng csrlin curdir$ cvb cvbyt cvd cvdwd cve cvf cvi cvl cvmd cvms cvq cvs cvwrd cwrd data date$ declare decr def defbcd defdbl defext deffix defflx defint deflng defqud defsng defstr delay delete descend dim dir$ do draw dynamic else elseif ems end endmem environ environ$ eof eqv eradr erase erdev erdev$ erl err errnum error errtest execute exit exp exp10 exp2 external extract$ far field fileattr files fix fixdigits flexchr$ flush fn for frac fre freefile from function get get$ gosub goto hex$ if imp impabs in incr inkey$ inp input input$ insert instat instr int interrupt ioctl ioctl$ isfalse istrue iterate key kill lbound lcase$ left left$ len let line list loc local locate lock lof log log10 log2 loop lpos lprint lset ltrim$ map max max$ max% mempack memset mid$ min min$ min% mkb$ mkbyt$ mkd$ mkdir mkdwd$ mke$ mkf$ mki$ mkl$ mkmd$ mkms$ mkq$ mks$ mkwrd$ mod mtimer multiplex name next not oct$ off on open option or out output paint palette peek peek$ peeki peekl pen play pmap point poke poke$ pokei pokel popup pos preset print pset public put put$ quiet random randomize read redim reg rem remove$ repeat$ replace reset restore resume return right right$ rmdir rnd rotate round rset rtrim$ run scan screen seek seg select setmem sgn shared shell shift signed sin sleep sort sound space$ spc sqr static step stick stop str$ strig string$ strptr strseg stuff sub swap system tab tagarray tally tan then time$ timer to troff tron type ubound ucase ucase$ uevent union unlock until using using$ val varptr varptr$ varseg verify view wait wend while width window with write xor""".split() _keywords_datatypes = """any bcd byte double dword extended fix flex integer long quad single string word""".split() _keywords_options = """ascend byval collate delete descend dynamic huge local preserve public shared static sort""".split() _keywords_proceedures = """arraycalc arrayinfo getstralloc getstrlen getstrloc rlsstralloc setonexit setonmempack setuevent pbvbinbase pbvcpu pbvcursor1 pbvcursor2 pbvcursorvis pbvdefseg pbverr pbvfixdigits pbvflexchr pbvhost pbvminusone pbvnpx pbvone pbvrevision pbvrevltr pbvscrnapage pbvscrnbuff pbvscrncard pbvscrncols pbvscrnmode pbvscrnpxlattr pbvscrnrows pbvscrntxtattr pbvscrnvpage pbvswitch pbvuserarea pbvusingchrs pbvvtxtx1 pbvvtxtx2 pbvvtxty1 pbvvtxty2 pbvzero""".split()
class koPowerBasicLanguage(KoCommonBasicLanguageService): name = "PowerBasic" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{0bc5c569-6546-45ec-8452-4636d326e0f7}" _reg_categories_ = [("komodo-language", name)] _stateMap = { 'default': ('SCE_B_DEFAULT',), 'keywords': ('SCE_B_KEYWORD', 'SCE_B_KEYWORD2', 'SCE_B_KEYWORD3', 'SCE_B_KEYWORD4'), 'identifiers': ('SCE_B_IDENTIFIER',), 'comments': ('SCE_B_COMMENT',), 'numbers': ('SCE_B_NUMBER',), 'strings': ('SCE_B_STRING',), 'stringeol': ('SCE_B_STRINGEOL',), 'operators': ('SCE_B_OPERATOR',), 'preprocessor': ('SCE_B_PREPROCESSOR',), 'date': ('SCE_B_DATE',), 'constants': ('SCE_B_CONSTANT',), 'assembly': ('SCE_B_ASM',), } defaultExtension = '.pb' commentDelimiterInfo = {"line": [ "rem ", "REM " ]} sample = """ INPUT "What is your name"; UserName$ PRINT "Hello "; UserName$ DO INPUT "How many stars do you want"; NumStars Stars$ = "" Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC --or-- Stars$ = STRING$(NumStars, "*") ' <- MS BASIC PRINT Stars$ DO INPUT "Do you want more stars"; Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1); LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Goodbye "; FOR I = 1 TO 200 PRINT UserName$; " "; NEXT I PRINT """ def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer( components.interfaces.ISciMoz.SCLEX_POWERBASIC) self._lexer.setKeywords(0, self._keywords_preprocessor + \ self._keywords_functions + \ self._keywords_proceedures + \ self._keywords_datatypes + \ self._keywords_options) self._lexer.supportsFolding = 1 return self._lexer _keywords_preprocessor = """$alias $code $com $compile $cpu $debug $dim $dynamic $endif $error $event $float $huge $if $include $inline $lib $link $optimize $option $segment $sound $stack $static $string all array cga chain cntlbreak com ega emulate exe fullfloat graph herc iprint lpt map memory none npx off path pbdebug procedure signed size speed unit unsigned vga""".split() _keywords_functions = """absolute access and any append array as asc ascend ascii asm at atn attrib base beep bin$ binary bit bits bload bsave call case cbcd cbyt cdbl cdwd ceil cext cfix chain chdir chdrive chr$ cint circle clear clng close cls codeptr codeseg collate color com command$ common cos cqud csng csrlin curdir$ cvb cvbyt cvd cvdwd cve cvf cvi cvl cvmd cvms cvq cvs cvwrd cwrd data date$ declare decr def defbcd defdbl defext deffix defflx defint deflng defqud defsng defstr delay delete descend dim dir$ do draw dynamic else elseif ems end endmem environ environ$ eof eqv eradr erase erdev erdev$ erl err errnum error errtest execute exit exp exp10 exp2 external extract$ far field fileattr files fix fixdigits flexchr$ flush fn for frac fre freefile from function get get$ gosub goto hex$ if imp impabs in incr inkey$ inp input input$ insert instat instr int interrupt ioctl ioctl$ isfalse istrue iterate key kill lbound lcase$ left left$ len let line list loc local locate lock lof log log10 log2 loop lpos lprint lset ltrim$ map max max$ max% mempack memset mid$ min min$ min% mkb$ mkbyt$ mkd$ mkdir mkdwd$ mke$ mkf$ mki$ mkl$ mkmd$ mkms$ mkq$ mks$ mkwrd$ mod mtimer multiplex name next not oct$ off on open option or out output paint palette peek peek$ peeki peekl pen play pmap point poke poke$ pokei pokel popup pos preset print pset public put put$ quiet random randomize read redim reg rem remove$ repeat$ replace reset restore resume return right right$ rmdir rnd rotate round rset rtrim$ run scan screen seek seg select setmem sgn shared shell shift signed sin sleep sort sound space$ spc sqr static step stick stop str$ strig string$ strptr strseg stuff sub swap system tab tagarray tally tan then time$ timer to troff tron type ubound ucase ucase$ uevent union unlock until using using$ val varptr varptr$ varseg verify view wait wend while width window with write xor""".split() _keywords_datatypes = """any bcd byte double dword extended fix flex integer long quad single string word""".split() _keywords_options = """ascend byval collate delete descend dynamic huge local preserve public shared static sort""".split() _keywords_proceedures = """arraycalc arrayinfo getstralloc getstrlen getstrloc rlsstralloc setonexit setonmempack setuevent pbvbinbase pbvcpu pbvcursor1 pbvcursor2 pbvcursorvis pbvdefseg pbverr pbvfixdigits pbvflexchr pbvhost pbvminusone pbvnpx pbvone pbvrevision pbvrevltr pbvscrnapage pbvscrnbuff pbvscrncard pbvscrncols pbvscrnmode pbvscrnpxlattr pbvscrnrows pbvscrntxtattr pbvscrnvpage pbvswitch pbvuserarea pbvusingchrs pbvvtxtx1 pbvvtxtx2 pbvvtxty1 pbvvtxty2 pbvzero""".split()
class basicBase(KoCommonBasicLanguageService): _keywords = None _keywords2 = None sciMozLexer = None commentDelimiterInfo = { "line": [ "'", "rem ", "REM " ], } _stateMap = { 'default': ('SCE_B_DEFAULT',), 'keywords': ('SCE_B_KEYWORD', 'SCE_B_KEYWORD2', 'SCE_B_KEYWORD3', 'SCE_B_KEYWORD4',), 'identifiers': ('SCE_B_IDENTIFIER',), 'comments': ('SCE_B_COMMENT',), 'numbers': ('SCE_B_NUMBER',), 'strings': ('SCE_B_STRING',), 'stringeol': ('SCE_B_STRINGEOL',), 'operators': ('SCE_B_OPERATOR',), 'preprocessor': ('SCE_B_PREPROCESSOR',), 'date': ('SCE_B_DATE',), 'constants': ('SCE_B_CONSTANT',), 'assembly': ('SCE_B_ASM',), } sample = """ INPUT "What is your name"; UserName$ PRINT "Hello "; UserName$ DO INPUT "How many stars do you want"; NumStars Stars$ = "" Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC --or-- Stars$ = STRING$(NumStars, "*") ' <- MS BASIC PRINT Stars$ DO INPUT "Do you want more stars"; Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1); LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Goodbye "; FOR I = 1 TO 200 PRINT UserName$; " "; NEXT I PRINT """ def __init__(self): KoCommonBasicLanguageService.__init__(self) del self.matchingSoftChars["'"] def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(self.sciMozLexer) self._lexer.setKeywords(0, self._keywords) if self._keywords2: self._lexer.setKeywords(1, self._keywords2) self._lexer.supportsFolding = 1 return self._lexer
class koGoLanguage(KoLanguageBase, KoLanguageBaseDedentMixin): name = "Go" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{2d6ed8b6-f079-441a-8b5a-10ef781cb989}" _reg_categories_ = [("komodo-language", name)] # Copy the base interfaces. _com_interfaces_ = KoLanguageBase._com_interfaces_[:] # Add koIInterpolationCallback - but it's only available in version 9 and # above - so catch the exception for earlier versions. try: _com_interfaces_.append(components.interfaces.koIInterpolationCallback) except: log.warn("koIInterpolationCallback does not exist") modeNames = ['go'] primary = 1 internal = 0 accessKey = 'g' defaultExtension = ".go" commentDelimiterInfo = { "line": ["//"], "block": [("/*", "*/")], "markup": "*", } _dedenting_statements = [u'goto', u'return', u'break', u'continue'] namedBlockRE = "^[ \t]*?(func\s+(?:\(.*?\)\s*)?\w|package\s+\w)" namedBlockDescription = 'Go functions, methods and packages' supportsSmartIndent = "brace" # The following sample contains embedded tabs because that's the Go way. sample = r"""\ package commands import ( "encoding/json" ) type Filters []string func (f *Filters) String() string { a := "a string" b := 'c' // a char c := 43 // a num return fmt.Sprint(*f) } /* Block comment on these two lines */ """ def __init__(self): KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR ], _variable_styles=[components.interfaces.ISciMoz.SCE_C_IDENTIFIER]) self._setupIndentCheckSoftChar() self._fastCharData = \ FastCharData(trigger_char=";", style_list=(sci_constants.SCE_C_OPERATOR,), skippable_chars_by_style={ sci_constants.SCE_C_OPERATOR : "])",}, for_check=True) # Add extensible items (available in komodo 9 and higher). if 'koIInterpolationService' in components.interfaces.keys(): interpolateSvc = components.classes["@activestate.com/koInterpolationService;1"].\ getService(components.interfaces.koIInterpolationService) try: interpolateSvc.addCode('go', self) except Exception: log.warn("Unable to add 'go' interpolation shortcut") def interpolationCallback(self, code, fileName, lineNum, word, selection, projectFile, prefs): if code == 'go': golangInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Go;1"].\ getService(components.interfaces.koIAppInfoEx) return golangInfoEx.executablePath raise RuntimeError("Unexpected go code %r" % (code, )) def getLanguageService(self, iid): return KoLanguageBase.getLanguageService(self, iid) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CPP) self._lexer.supportsFolding = 1 self._lexer.setProperty('lexer.cpp.allow.dollars', '0') self._lexer.setProperty('fold.cpp.syntax.based', '1') self._lexer.setProperty('lexer.cpp.backquoted.strings', '1') self._lexer.setKeywords(0, GoLangInfo.reserved_keywords) # The CPP lexer reserves keywords(2) for comment doc keywords and # keywords(3) for "SCE_C_GLOBALCLASS", so treat the # predeclared_identifiers (like 'bool') and # the predefined_functions (like 'append') as the same. other_words = (GoLangInfo.predeclared_identifiers.union( GoLangInfo.predeclared_functions)) self._lexer.setKeywords(1, other_words) return self._lexer
class koGoLanguage(KoLanguageBase, KoLanguageBaseDedentMixin): name = "Go" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{2d6ed8b6-f079-441a-8b5a-10ef781cb989}" _reg_categories_ = [("komodo-language", name)] # Copy the base interfaces. _com_interfaces_ = KoLanguageBase._com_interfaces_[:] # Add koIInterpolationCallback - but it's only available in version 9 and # above - so catch the exception for earlier versions. try: _com_interfaces_.append(components.interfaces.koIInterpolationCallback) except: log.warn("koIInterpolationCallback does not exist") modeNames = ["go"] primary = 1 internal = 0 accessKey = "g" defaultExtension = ".go" commentDelimiterInfo = {"line": ["//"], "block": [("/*", "*/")], "markup": "*"} _dedenting_statements = [u"goto", u"return", u"break", u"continue"] namedBlockRE = "^[ \t]*?(func\s+(?:\(.*?\)\s*)?\w|package\s+\w)" namedBlockDescription = "Go functions, methods and packages" supportsSmartIndent = "brace" # The following sample contains embedded tabs because that's the Go way. sample = r"""\ package commands import ( "encoding/json" ) type Filters []string func (f *Filters) String() string { a := "a string" b := 'c' // a char c := 43 // a num return fmt.Sprint(*f) } /* Block comment on these two lines */ """ def __init__(self): KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR, ], _variable_styles=[components.interfaces.ISciMoz.SCE_C_IDENTIFIER], ) self._setupIndentCheckSoftChar() self._fastCharData = FastCharData( trigger_char=";", style_list=(sci_constants.SCE_C_OPERATOR,), skippable_chars_by_style={sci_constants.SCE_C_OPERATOR: "])"}, for_check=True, ) # And add the new default prefs if they don't exist globalPrefs = ( components.classes["@activestate.com/koPrefService;1"] .getService(components.interfaces.koIPrefService) .prefs ) # Chunk adding prefs based on which ones they were added with. if not globalPrefs.hasPref("gocodeDefaultLocation"): globalPrefs.setStringPref("gocodeDefaultLocation", "") if not globalPrefs.hasPref("godefDefaultLocation"): globalPrefs.setStringPref("godefDefaultLocation", "") if not globalPrefs.hasPref("golangDefaultLocation"): globalPrefs.setStringPref("golangDefaultLocation", "") globalPrefs.setStringPref("Go/newEncoding", "utf-8") globalPrefs.setLongPref("Go/indentWidth", 8) globalPrefs.setBooleanPref("Go/useTabs", True) # Add the go formatter. if not globalPrefs.getBoolean("haveInstalledGoFormatter", False): if globalPrefs.hasPref("configuredFormatters"): formatters = globalPrefs.getPref("configuredFormatters") go_formatter_prefset = components.classes["@activestate.com/koPreferenceSet;1"].createInstance( components.interfaces.koIPreferenceSet ) uuid = "{cf500001-ec59-4047-86e7-369d257f4b80}" go_formatter_prefset.id = uuid go_formatter_prefset.setStringPref("lang", "Go") go_formatter_prefset.setStringPref("name", "GoFmt") go_formatter_prefset.setStringPref("uuid", uuid) go_formatter_prefset.setStringPref("formatter_name", "generic") args_prefset = components.classes["@activestate.com/koPreferenceSet;1"].createInstance( components.interfaces.koIPreferenceSet ) args_prefset.id = "genericFormatterPrefs" args_prefset.setStringPref("executable", "%(go)fmt") args_prefset.setStringPref("arguments", "-w=false") go_formatter_prefset.setPref("genericFormatterPrefs", args_prefset) formatters.appendString(uuid) globalPrefs.setPref(uuid, go_formatter_prefset) globalPrefs.setBoolean("haveInstalledGoFormatter", True) # Add extensible items (available in komodo 9 and higher). if "koIInterpolationService" in components.interfaces.keys(): interpolateSvc = components.classes["@activestate.com/koInterpolationService;1"].getService( components.interfaces.koIInterpolationService ) try: interpolateSvc.addCode("go", self) except Exception: log.warn("Unable to add 'go' interpolation shortcut") def interpolationCallback(self, code, fileName, lineNum, word, selection, projectFile, prefs): if code == "go": golangInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Go;1"].getService( components.interfaces.koIAppInfoEx ) return golangInfoEx.executablePath raise RuntimeError("Unexpected go code %r" % (code,)) def getLanguageService(self, iid): return KoLanguageBase.getLanguageService(self, iid) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CPP) self._lexer.supportsFolding = 1 self._lexer.setProperty("lexer.cpp.allow.dollars", "0") self._lexer.setProperty("fold.cpp.syntax.based", "1") self._lexer.setProperty("lexer.cpp.backquoted.strings", "1") self._lexer.setKeywords(0, GoLangInfo.reserved_keywords) # The CPP lexer reserves keywords(2) for comment doc keywords and # keywords(3) for "SCE_C_GLOBALCLASS", so treat the # predeclared_identifiers (like 'bool') and # the predefined_functions (like 'append') as the same. other_words = GoLangInfo.predeclared_identifiers.union(GoLangInfo.predeclared_functions) self._lexer.setKeywords(1, other_words) return self._lexer
class koGoLanguage(KoLanguageBase, KoLanguageBaseDedentMixin): name = "Go" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{2d6ed8b6-f079-441a-8b5a-10ef781cb989}" _reg_categories_ = [("komodo-language", name)] # Copy the base interfaces. _com_interfaces_ = KoLanguageBase._com_interfaces_[:] # Add koIInterpolationCallback - but it's only available in version 9 and # above - so catch the exception for earlier versions. try: _com_interfaces_.append(components.interfaces.koIInterpolationCallback) except: log.warn("koIInterpolationCallback does not exist") modeNames = ['go'] primary = 1 internal = 0 accessKey = 'g' defaultExtension = ".go" commentDelimiterInfo = { "line": [ "//" ], "block": [ ("/*", "*/") ], "markup": "*", } _dedenting_statements = [u'goto', u'return', u'break', u'continue'] namedBlockRE = "^[ \t]*?(func\s+(?:\(.*?\)\s*)?\w|package\s+\w)" namedBlockDescription = 'Go functions, methods and packages' supportsSmartIndent = "brace" # The following sample contains embedded tabs because that's the Go way. sample = r"""\ package commands import ( "encoding/json" ) type Filters []string func (f *Filters) String() string { a := "a string" b := 'c' // a char c := 43 // a num return fmt.Sprint(*f) } /* Block comment on these two lines */ """ def __init__(self): KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR], _variable_styles = [components.interfaces.ISciMoz.SCE_C_IDENTIFIER] ) self._setupIndentCheckSoftChar() self._fastCharData = \ FastCharData(trigger_char=";", style_list=(sci_constants.SCE_C_OPERATOR,), skippable_chars_by_style={ sci_constants.SCE_C_OPERATOR : "])",}, for_check=True) # Add extensible items (available in komodo 9 and higher). if 'koIInterpolationService' in components.interfaces.keys(): interpolateSvc = components.classes["@activestate.com/koInterpolationService;1"].\ getService(components.interfaces.koIInterpolationService) try: interpolateSvc.addCode('go', self) except Exception: log.warn("Unable to add 'go' interpolation shortcut") def interpolationCallback(self, code, fileName, lineNum, word, selection, projectFile, prefs): if code == 'go': golangInfoEx = components.classes["@activestate.com/koAppInfoEx?app=Go;1"].\ getService(components.interfaces.koIAppInfoEx) return golangInfoEx.executablePath raise RuntimeError("Unexpected go code %r" % (code, )) def getLanguageService(self, iid): return KoLanguageBase.getLanguageService(self, iid) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CPP) self._lexer.supportsFolding = 1 self._lexer.setProperty('lexer.cpp.allow.dollars', '0') self._lexer.setProperty('fold.cpp.syntax.based', '1') self._lexer.setProperty('lexer.cpp.backquoted.strings', '1') self._lexer.setKeywords(0, GoLangInfo.reserved_keywords) # The CPP lexer reserves keywords(2) for comment doc keywords and # keywords(3) for "SCE_C_GLOBALCLASS", so treat the # predeclared_identifiers (like 'bool') and # the predefined_functions (like 'append') as the same. other_words = (GoLangInfo.predeclared_identifiers. union(GoLangInfo.predeclared_functions)) self._lexer.setKeywords(1, other_words) return self._lexer
class koPascalLanguage(KoLanguageKeywordBase): name = "Pascal" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{8AE35E4C-0EC9-49f2-A534-8FEAB91D261D}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".pas" commentDelimiterInfo = { # See the following for info on Pascal comments: # http://www.math.uni-hamburg.de/it/software/fpk/ref/node7.html # XXX The line Pascal comment is a Delphi only thing, so I am leaving # it out for now. # "line": [ "//" ], "block": [("{", "}"), ("(*", "*)")], "markup": "*", } supportsSmartIndent = "keyword" _indenting_statements = ["begin", "record", "repeat", "case"] _dedenting_statements = ["goto", "halt"] _keyword_dedenting_keywords = ["end", "until"] _stateMap = { "default": ("SCE_PAS_DEFAULT",), "keywords": ("SCE_PAS_WORD", "SCE_PAS_ASM"), "comments": ("SCE_PAS_COMMENT", "SCE_PAS_COMMENT2", "SCE_PAS_COMMENTLINE"), "identifiers": ("SCE_PAS_IDENTIFIER",), "preprocessor": ("SCE_PAS_PREPROCESSOR", "SCE_PAS_PREPROCESSOR2"), "numbers": ("SCE_PAS_NUMBER", "SCE_PAS_HEXNUMBER"), "strings": ("SCE_PAS_STRING", "SCE_PAS_STRINGEOL", "SCE_PAS_CHARACTER"), } sample = """ program MyProg(input, output) (* Warning: this program might not compile. *) begin { that's because there's no Pascal compiler on this machine. } var myVar:integer; myVar := 5; if (myVar > 3) begin writeln("Pascal is fun!!!!") end end end. """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_PAS_COMMENT, sci_constants.SCE_PAS_COMMENT2, sci_constants.SCE_PAS_COMMENTLINE, ], _indent_styles=[sci_constants.SCE_PAS_OPERATOR], _variable_styles=[sci_constants.SCE_PAS_IDENTIFIER], _lineup_close_styles=[sci_constants.SCE_PAS_OPERATOR], _lineup_styles=[sci_constants.SCE_PAS_OPERATOR], _keyword_styles=[sci_constants.SCE_PAS_WORD], _default_styles=[sci_constants.SCE_PAS_DEFAULT], _ignorable_styles=[ sci_constants.SCE_PAS_COMMENT, sci_constants.SCE_PAS_COMMENT2, sci_constants.SCE_PAS_COMMENTLINE, sci_constants.SCE_PAS_NUMBER, ], ) self._fastCharData = FastCharData( trigger_char=";", style_list=(sci_constants.SCE_PAS_OPERATOR,), skippable_chars_by_style={sci_constants.SCE_PAS_OPERATOR: "])"}, for_check=True, ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_PASCAL) self._lexer.setKeywords(0, self._keywords) self._lexer.setKeywords(1, self._keywords2) self._lexer.supportsFolding = 1 return self._lexer _keywords = """and array asm begin case cdecl class const constructor default destructor div do downto else end end. except exit exports external far file finalization finally for function goto if implementation in index inherited initialization inline interface label library message mod near nil not object of on or out overload override packed pascal private procedure program property protected public published raise read record register repeat resourcestring safecall set shl shr stdcall stored string then threadvar to try type unit until uses var virtual while with write writeln xor""".split() _keywords2 = """write read default public protected private property published stored""".split()
class koPascalLanguage(KoLanguageKeywordBase): name = "Pascal" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{8AE35E4C-0EC9-49f2-A534-8FEAB91D261D}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".pas" commentDelimiterInfo = { # See the following for info on Pascal comments: # http://www.math.uni-hamburg.de/it/software/fpk/ref/node7.html #XXX The line Pascal comment is a Delphi only thing, so I am leaving # it out for now. #"line": [ "//" ], "block": [ ("{", "}"), ("(*", "*)") ], "markup": "*", } supportsSmartIndent = "keyword" _indenting_statements = ['begin', 'record', 'repeat', 'case', ] _dedenting_statements = ['goto', 'halt', ] _keyword_dedenting_keywords = ['end', 'until', ] _stateMap = { 'default': ('SCE_PAS_DEFAULT',), 'keywords': ('SCE_PAS_WORD', 'SCE_PAS_ASM'), 'comments': ('SCE_PAS_COMMENT', 'SCE_PAS_COMMENT2', 'SCE_PAS_COMMENTLINE',), 'identifiers': ('SCE_PAS_IDENTIFIER',), 'preprocessor': ('SCE_PAS_PREPROCESSOR', 'SCE_PAS_PREPROCESSOR2'), 'numbers': ('SCE_PAS_NUMBER', 'SCE_PAS_HEXNUMBER',), 'strings': ('SCE_PAS_STRING', 'SCE_PAS_STRINGEOL', 'SCE_PAS_CHARACTER',), } sample = """ program MyProg(input, output) (* Warning: this program might not compile. *) begin { that's because there's no Pascal compiler on this machine. } var myVar:integer; myVar := 5; if (myVar > 3) begin writeln("Pascal is fun!!!!") end end end. """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_PAS_COMMENT, sci_constants.SCE_PAS_COMMENT2, sci_constants.SCE_PAS_COMMENTLINE], _indent_styles = [sci_constants.SCE_PAS_OPERATOR], _variable_styles = [sci_constants.SCE_PAS_IDENTIFIER], _lineup_close_styles = [sci_constants.SCE_PAS_OPERATOR], _lineup_styles = [sci_constants.SCE_PAS_OPERATOR], _keyword_styles = [sci_constants.SCE_PAS_WORD], _default_styles = [sci_constants.SCE_PAS_DEFAULT], _ignorable_styles = [sci_constants.SCE_PAS_COMMENT, sci_constants.SCE_PAS_COMMENT2, sci_constants.SCE_PAS_COMMENTLINE, sci_constants.SCE_PAS_NUMBER], ) self._fastCharData = \ FastCharData(trigger_char=";", style_list=(sci_constants.SCE_PAS_OPERATOR, ), skippable_chars_by_style={ sci_constants.SCE_PAS_OPERATOR : "])" }, for_check=True) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_PASCAL) self._lexer.setKeywords(0, self._keywords) self._lexer.setKeywords(1, self._keywords2) self._lexer.supportsFolding = 1 return self._lexer _keywords = """and array asm begin case cdecl class const constructor default destructor div do downto else end end. except exit exports external far file finalization finally for function goto if implementation in index inherited initialization inline interface label library message mod near nil not object of on or out overload override packed pascal private procedure program property protected public published raise read record register repeat resourcestring safecall set shl shr stdcall stored string then threadvar to try type unit until uses var virtual while with write writeln xor""".split() _keywords2 = """write read default public protected private property published stored""".split()
class koGoLanguage(KoLanguageBase, KoLanguageBaseDedentMixin): name = "Go" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{2d6ed8b6-f079-441a-8b5a-10ef781cb989}" _reg_categories_ = [("komodo-language", name)] modeNames = ["go"] primary = 1 internal = 0 accessKey = "g" defaultExtension = ".go" commentDelimiterInfo = {"line": ["//"], "block": [("/*", "*/")], "markup": "*"} _dedenting_statements = [u"goto", u"return", u"break", u"continue"] namedBlockRE = "^[ \t]*?(func\s+(?:\(.*?\)\s*)?\w|package\s+\w)" namedBlockDescription = "Go functions, methods and packages" supportsSmartIndent = "brace" # The following sample contains embedded tabs because that's the Go way. sample = r"""\ package commands import ( "encoding/json" ) type Filters []string func (f *Filters) String() string { a := "a string" b := 'c' // a char c := 43 // a num return fmt.Sprint(*f) } /* Block comment on these two lines */ """ def __init__(self): KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR, ], _variable_styles=[components.interfaces.ISciMoz.SCE_C_IDENTIFIER], ) self._setupIndentCheckSoftChar() self._fastCharData = FastCharData( trigger_char=";", style_list=(sci_constants.SCE_C_OPERATOR,), skippable_chars_by_style={sci_constants.SCE_C_OPERATOR: "])"}, for_check=True, ) # And add the new default prefs if they don't exist globalPrefs = ( components.classes["@activestate.com/koPrefService;1"] .getService(components.interfaces.koIPrefService) .prefs ) # Chunk adding prefs based on which ones they were added with. if not globalPrefs.hasPref("gocodeDefaultLocation"): globalPrefs.setStringPref("gocodeDefaultLocation", "") if not globalPrefs.hasPref("godefDefaultLocation"): globalPrefs.setStringPref("godefDefaultLocation", "") if not globalPrefs.hasPref("golangDefaultLocation"): globalPrefs.setStringPref("golangDefaultLocation", "") globalPrefs.setStringPref("Go/newEncoding", "utf-8") globalPrefs.setLongPref("Go/indentWidth", 8) globalPrefs.setBooleanPref("Go/useTabs", True) # TODO: Add formatter prefs along the lines of: # <!-- Go formatter --> # <preference-set > # <string id="formatter_name">generic</string> # <string id="lang">Go</string> # <string id="name">Go Reformatter</string> # <string id="uuid">{286d5b45-a54e-4317-b3c8-da4dc35673a4}</string> # </preference-set> def getLanguageService(self, iid): return KoLanguageBase.getLanguageService(self, iid) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CPP) self._lexer.supportsFolding = 1 self._lexer.setProperty("lexer.cpp.allow.dollars", "0") self._lexer.setProperty("fold.cpp.syntax.based", "1") self._lexer.setProperty("lexer.cpp.backquoted.strings", "1") self._lexer.setKeywords(0, GoLangInfo.reserved_keywords) # The CPP lexer reserves keywords(2) for comment doc keywords and # keywords(3) for "SCE_C_GLOBALCLASS", so treat the # predeclared_identifiers (like 'bool') and # the predefined_functions (like 'append') as the same. other_words = GoLangInfo.predeclared_identifiers.union(GoLangInfo.predeclared_functions) self._lexer.setKeywords(1, other_words) return self._lexer
class koLuaLanguage(KoLanguageKeywordBase): name = "Lua" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{D3C94E8B-B75C-4fa4-BC4D-986F68ACD33C}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".lua" commentDelimiterInfo = { "line": ["--"], "block": [("--[[", "]]")], } supportsSmartIndent = "keyword" _indenting_statements = [ 'function', 'if', 'for', 'repeat', 'while', 'else', 'elseif', 'do' ] _dedenting_statements = ['break', 'return', 'error'] # These trigger a dedent when entered, but then count +1 # This might be better than putting 'else' in both # _indenting_statements and _keyword_dedenting_keywords _keyword_dedenting_keywords = ['end', 'else', 'elseif', 'until'] sample = """require "lfs" function dirtree(dir) assert(dir and dir ~= "", "directory parameter is missing or empty") if string.sub(dir, -1) == "/" then dir=string.sub(dir, 1, -2) end local diriters = {lfs.dir(dir)} local dirs = {dir} return function() repeat local entry = diriters[#diriters]() if entry then if entry ~= "." and entry ~= ".." then local filename = table.concat(dirs, "/").."/"..entry local attr = lfs.attributes(filename) if attr.mode == "directory" then table.insert(dirs, entry) table.insert(diriters, lfs.dir(filename)) end return filename, attr end else table.remove(dirs) table.remove(diriters) end until #diriters==0 end end """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC ], _indent_styles=[sci_constants.SCE_LUA_OPERATOR], _variable_styles=[sci_constants.SCE_LUA_IDENTIFIER], _lineup_close_styles=[sci_constants.SCE_LUA_OPERATOR], _lineup_styles=[sci_constants.SCE_LUA_OPERATOR], _keyword_styles=[ sci_constants.SCE_LUA_WORD, sci_constants.SCE_LUA_WORD2, sci_constants.SCE_LUA_WORD3, sci_constants.SCE_LUA_WORD4, sci_constants.SCE_LUA_WORD5, sci_constants.SCE_LUA_WORD6, sci_constants.SCE_LUA_WORD7, sci_constants.SCE_LUA_WORD8, ], _default_styles=[sci_constants.SCE_LUA_DEFAULT], _ignorable_styles=[ sci_constants.SCE_LUA_COMMENT, sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC, sci_constants.SCE_LUA_NUMBER ], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_LUA) self._lexer.setKeywords(0, self._keywords) self._lexer.setKeywords(1, self._keywords1) self._lexer.supportsFolding = 1 return self._lexer # Reserved words. _keywords = [ "and", "break", "do", "else", "elseif", "end", "false", "for", "function", "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while" ] # Global functions and constants, and libraries. _keywords1 = [ "assert", "collectgarbage", "dofile", "error", "getmetatable", "ipairs", "load", "loadfile", "next", "pairs", "pcall", "print", "rawequal", "rawget", "rawset", "require", "select", "setmetatable", "tonumber", "tostring", "type", "xpcall", "_G", "_VERSION", # New in Lua 5.2. "rawlen", "_ENV", # Deprecated in 5.2. "getfenv", "loadstring", "module", "setfenv", "unpack" "string", "string.byte", "string.char", "string.dump", "string.find", "string.format", "string.gmatch", "string.gsub", "string.len", "string.lower", "string.match", "string.rep", "string.reverse", "string.sub", "string.upper", # New in Lua 5.3. "string.pack", "string.packsize", "string.unpack", "table", "table.concat", "table.insert", "table.remove", "table.sort", # New in 5.2. "table.pack", "table.unpack", # New in in 5.3. "table.move", "math", "math.abs", "math.acos", "math.asin", "math.atan", "math.ceil", "math.cos", "math.deg", "math.exp", "math.floor", "math.fmod", "math.huge", "math.log", "math.max", "math.min", "math.modf", "math.pi", "math.rad", "math.random", "math.randomseed", "math.sin", "math.sqrt", "math.tan", # New in 5.3. "math.maxinteger", "math.mininteger", "math.tointeger", "math.type", "math.ult", "coroutine", "coroutine.create", "coroutine.resume", "coroutine.running", "coroutine.status", "coroutine.wrap", "coroutine.yield", # New in Lua 5.3. "coroutine.isyieldable", "package", "package.cpath", "package.loaded", "package.loadlib", "package.path", "package.preload", # New in 5.2. "package.config", "package.searchers", "package.searchpath", "utf8", "utf8.char", "utf8.charpattern", "utf8.codepoint", "utf8.codes", "utf8.len", "utf8.offset", "io", "io.close", "io.flush", "io.input", "io.lines", "io.open", "io.output", "io.popen", "io.read", "io.stderr", "io.stdin", "io.stdout", "io.tmpfile", "io.type", "io.write", "os", "os.clock", "os.date", "os.difftime", "os.execute", "os.exit", "os.getenv", "os.remove", "os.rename", "os.setlocale", "os.time", "os.tmpname", "debug", "debug.debug", "debug.gethook", "debug.getinfo", "debug.getlocal", "debug.getmetatable", "debug.getregistry", "debug.getupvalue", "debug.sethook", "debug.setlocal", "debug.setmetatable", "debug.setupvalue", "debug.traceback", # New in Lua 5.2. "debug.getuservalue", "debug.setuservalue", "debug.upvalueid", "debug.upvaluejoin" ] #XXX: Override _indentingOrDedentingStatement looking for things like # return function ... # Override: # Handle return ... function differently def computeIndent(self, scimoz, indentStyle, continueComments): if continueComments: return KoLanguageKeywordBase.computeIndent(self, scimoz, indentStyle, continueComments) calculatedData = self.getTokenDataForComputeIndent( scimoz, self._style_info) indent = self._computeIndent(scimoz, indentStyle, continueComments, self._style_info, calculatedData) if indent is not None: return indent return KoLanguageKeywordBase.computeIndent( self, scimoz, indentStyle, continueComments, calculatedData=calculatedData) def _computeIndent(self, scimoz, indentStyle, continueComments, style_info, calculatedData): non_ws_tokens = calculatedData['non_ws_tokens'] if not self._lookingAtReturnFunction(non_ws_tokens, style_info): return None tok0 = calculatedData['tokens'][0] indent = scimoz.indent if not indent: indent = scimoz.tabWidth # if 0, Scintilla uses tabWidth if tok0.style in style_info._default_styles: currWSLen = len(tok0.text.expandtabs(scimoz.tabWidth)) newWSLen = currWSLen + indent else: newWSLen = indent return scimozindent.makeIndentFromWidth(scimoz, newWSLen) def _lookingAtReturnFunction(self, non_ws_tokens, style_info): return (len(non_ws_tokens) >= 2 and non_ws_tokens[0].style in style_info._keyword_styles and non_ws_tokens[0].text == "return" and non_ws_tokens[1].style in style_info._keyword_styles and non_ws_tokens[1].text == "function")
class koHLSLLanguage(KoLanguageBase): name = "HLSL" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{fd0846b3-ff7f-41af-b324-179783084469}" _reg_categories_ = [("komodo-language", name)] primary = 0 defaultExtension = ".hlsl" commentDelimiterInfo = { "line": ["//"], "block": [("/*", "*/")], "markup": "*", } _dedenting_statements = [u'throw', u'return', u'break', u'continue'] _indenting_statements = [u'case'] searchURL = "http://www.google.com/search?q=hlsl+site%3Amicrosoft.com%2F+%W" # matches: # function name # name: function # name = function # class.prototype.name = function namedBlockDescription = 'HLSL functions and classes' namedBlockRE = r'^[ |\t]*?(?:([\w|\.|_]*?)\s*=\s*function|function\s*([\w|\_]*?)|([\w|\_]*?)\s*:\s*function).*?$' supportsSmartIndent = "brace" sample = """ float4 normal = mul(IN.Normal, ModelViewIT); normal.w = 0.0; normal = normalize(normal); float4 light = normalize(LightVec); float4 eye = float4(1.0, 1.0, 1.0, 0.0); float4 vhalf = normalize(light + eye); """ styleStdin = sci_constants.SCE_C_STDIN styleStdout = sci_constants.SCE_C_STDOUT styleStderr = sci_constants.SCE_C_STDERR def __init__(self): # Same as JavaScript's KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles=[ sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR ], _variable_styles=[sci_constants.SCE_C_IDENTIFIER]) self._setupIndentCheckSoftChar() def getVariableStyles(self): # Same as JavaScript's return self._style_info._variable_styles def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(sci_constants.SCLEX_CPP) self._lexer.setKeywords(0, HLSLLangInfo.keywords) self._lexer.setProperty('fold.cpp.syntax.based', '1') self._lexer.supportsFolding = 1 return self._lexer
class koLuaLanguage(KoLanguageKeywordBase): name = "Lua" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{D3C94E8B-B75C-4fa4-BC4D-986F68ACD33C}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".lua" commentDelimiterInfo = { "line": [ "--" ], "block": [ ("--[[", "]]") ], } supportsSmartIndent = "keyword" _indenting_statements = ['function', 'if', 'for', 'repeat', 'while', 'else', 'elseif', 'do'] _dedenting_statements = ['break', 'continue', 'return', 'error'] # These trigger a dedent when entered, but then count +1 # This might be better than putting 'else' in both # _indenting_statements and _keyword_dedenting_keywords _keyword_dedenting_keywords = ['end', 'else', 'elseif', 'until'] sample = """require "lfs" function dirtree(dir) assert(dir and dir ~= "", "directory parameter is missing or empty") if string.sub(dir, -1) == "/" then dir=string.sub(dir, 1, -2) end local diriters = {lfs.dir(dir)} local dirs = {dir} return function() repeat local entry = diriters[#diriters]() if entry then if entry ~= "." and entry ~= ".." then local filename = table.concat(dirs, "/").."/"..entry local attr = lfs.attributes(filename) if attr.mode == "directory" then table.insert(dirs, entry) table.insert(diriters, lfs.dir(filename)) end return filename, attr end else table.remove(dirs) table.remove(diriters) end until #diriters==0 end end """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC], _indent_styles = [sci_constants.SCE_LUA_OPERATOR], _variable_styles = [sci_constants.SCE_LUA_IDENTIFIER], _lineup_close_styles = [sci_constants.SCE_LUA_OPERATOR], _lineup_styles = [sci_constants.SCE_LUA_OPERATOR], _keyword_styles = [sci_constants.SCE_LUA_WORD, sci_constants.SCE_LUA_WORD2, sci_constants.SCE_LUA_WORD3, sci_constants.SCE_LUA_WORD4, sci_constants.SCE_LUA_WORD5, sci_constants.SCE_LUA_WORD6, sci_constants.SCE_LUA_WORD7, sci_constants.SCE_LUA_WORD8, ], _default_styles = [sci_constants.SCE_LUA_DEFAULT], _ignorable_styles = [sci_constants.SCE_LUA_COMMENT, sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC, sci_constants.SCE_LUA_NUMBER], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_LUA) self._lexer.setKeywords(0, self._keywords) self._lexer.setKeywords(1, self._keywords1) self._lexer.supportsFolding = 1 return self._lexer _keywords = ["and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while"] _keywords1 = ['require', 'assert', 'string', 'table', 'collectgarbage', 'dofile', 'error', '_G', 'getmetatable', 'ipairs', 'load', 'loadfile', 'next', 'pairs', 'pcall', 'print', 'rawequal', 'rawget', 'rawlen', 'rawset', 'select', 'setmetatable', 'tonumber', 'tostring', 'type', '_VERSION', 'xpcall',] #XXX: Override _indentingOrDedentingStatement looking for things like # return function ... # Override: # Handle return ... function differently def computeIndent(self, scimoz, indentStyle, continueComments): if continueComments: return KoLanguageKeywordBase.computeIndent(self, scimoz, indentStyle, continueComments) calculatedData = self.getTokenDataForComputeIndent(scimoz, self._style_info) indent = self._computeIndent(scimoz, indentStyle, continueComments, self._style_info, calculatedData) if indent is not None: return indent return KoLanguageKeywordBase.computeIndent(self, scimoz, indentStyle, continueComments, calculatedData=calculatedData) def _computeIndent(self, scimoz, indentStyle, continueComments, style_info, calculatedData): non_ws_tokens = calculatedData['non_ws_tokens'] if not self._lookingAtReturnFunction(non_ws_tokens, style_info): return None tok0 = calculatedData['tokens'][0] if tok0.style in style_info._default_styles: currWSLen = len(tok0.text.expandtabs(scimoz.tabWidth)) newWSLen = currWSLen + scimoz.indent else: newWSLen = scimoz.indent return scimozindent.makeIndentFromWidth(scimoz, newWSLen) def _lookingAtReturnFunction(self, non_ws_tokens, style_info): return (len(non_ws_tokens) >= 2 and non_ws_tokens[0].style in style_info._keyword_styles and non_ws_tokens[0].text == "return" and non_ws_tokens[1].style in style_info._keyword_styles and non_ws_tokens[1].text == "function")
class koHLSLLanguage(KoLanguageBase): name = "HLSL" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{fd0846b3-ff7f-41af-b324-179783084469}" _reg_categories_ = [("komodo-language", name)] primary = 0 defaultExtension = ".hlsl" commentDelimiterInfo = { "line": [ "//" ], "block": [ ("/*", "*/") ], "markup": "*", } _dedenting_statements = [u'throw', u'return', u'break', u'continue'] _indenting_statements = [u'case'] searchURL = "http://www.google.com/search?q=hlsl+site%3Amicrosoft.com%2F+%W" # matches: # function name # name: function # name = function # class.prototype.name = function namedBlockDescription = 'HLSL functions and classes' namedBlockRE = r'^[ |\t]*?(?:([\w|\.|_]*?)\s*=\s*function|function\s*([\w|\_]*?)|([\w|\_]*?)\s*:\s*function).*?$' supportsSmartIndent = "brace" sample = """ float4 normal = mul(IN.Normal, ModelViewIT); normal.w = 0.0; normal = normalize(normal); float4 light = normalize(LightVec); float4 eye = float4(1.0, 1.0, 1.0, 0.0); float4 vhalf = normalize(light + eye); """ styleStdin = sci_constants.SCE_C_STDIN styleStdout = sci_constants.SCE_C_STDOUT styleStderr = sci_constants.SCE_C_STDERR def __init__(self): # Same as JavaScript's KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR], _variable_styles = [sci_constants.SCE_C_IDENTIFIER] ) self._setupIndentCheckSoftChar() def getVariableStyles(self): # Same as JavaScript's return self._style_info._variable_styles def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(sci_constants.SCLEX_CPP) self._lexer.setKeywords(0, HLSLLangInfo.keywords) self._lexer.setProperty('fold.cpp.syntax.based', '1') self._lexer.supportsFolding = 1 return self._lexer
class koMatlabLanguage(KoLanguageKeywordBase): name = "Matlab" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{913BAE69-8E17-4c91-B855-687F0A34CFF6}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".m.matlab" extraFileAssociations = ["*.m", "*.matlab"] commentDelimiterInfo = {"line": ["%", "#"]} supportsSmartIndent = "keyword" # See comment in koLuaLanguage.py for why some keywords are in both # _indenting_statements and _keyword_dedenting_keywords _indenting_statements = [ "function", "if", "for", "parfor", "while", "else", "do", "elseif", "switch", "case", "otherwise", ] _dedenting_statements = ["break", "continue", "return", "error"] _keyword_dedenting_keywords = ["end", "else", "elseif", "case", "otherwise", "until"] _keywords = """break case catch classdef continue else elseif end error for function global if otherwise parfor persistent return spmd switch try while""".split() sciLexer = components.interfaces.ISciMoz.SCLEX_MATLAB def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles=[sci_constants.SCE_MATLAB_COMMENT], _indent_styles=[sci_constants.SCE_MATLAB_OPERATOR], _variable_styles=[sci_constants.SCE_MATLAB_IDENTIFIER], _lineup_close_styles=[sci_constants.SCE_MATLAB_OPERATOR], _lineup_styles=[sci_constants.SCE_MATLAB_OPERATOR], _keyword_styles=[sci_constants.SCE_MATLAB_KEYWORD], _default_styles=[sci_constants.SCE_MATLAB_DEFAULT], _ignorable_styles=[sci_constants.SCE_MATLAB_COMMENT, sci_constants.SCE_MATLAB_NUMBER], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(self.sciLexer) self._lexer.setKeywords(0, self._keywords) self._lexer.supportsFolding = 1 return self._lexer # matches: # function [output] = name(input) # classdef name < super # %% cell title namedBlockDescription = "Matlab functions and classes" namedBlockRE = r"(?:\b(?:function|classdef)\s+\w+|^\s*%%\s+\w+.*)" searchURL = "http://www.mathworks.com/help/search/doc/en/?qdoc=%W" sample = r"""function b = acyclic(adj_mat, directed)
class koBashLanguage(KoLanguageKeywordBase): name = "Bash" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{728daa03-1f7a-4eef-bb7b-de7b322825fa}" _reg_categories_ = [("komodo-language", name)] _stateMap = { 'operators': ('SCE_SH_OPERATOR', 'SCE_SH_BACKTICKS',), 'parameters': ('SCE_SH_PARAM',), 'errors': ('SCE_SH_ERROR',), 'variables': ('SCE_SH_SCALAR',), 'default': ('SCE_SH_DEFAULT',), 'numbers': ('SCE_SH_NUMBER',), 'identifiers': ('SCE_SH_IDENTIFIER',), 'strings': ('SCE_SH_CHARACTER', 'SCE_SH_STRING',), 'here documents': ('SCE_SH_HERE_DELIM', 'SCE_SH_HERE_Q',), 'comments': ('SCE_SH_COMMENTLINE',), 'keywords': ('SCE_SH_WORD',), } defaultExtension = '.sh' commentDelimiterInfo = {"line": [ "#" ],} shebangPatterns = [ re.compile(ur'\A#!.*/(ba)?sh.*$', re.IGNORECASE | re.MULTILINE), ] # Ignore parens due to case statements. _lineup_chars = u"{}" _lineup_open_chars = "{" _lineup_close_chars = "}" supportsSmartIndent = "keyword" # 'then' is kind of weird, but can be treated just like 'else' _indenting_statements = ['if', 'for', 'until', 'while', 'else', 'then', 'do'] _dedenting_statements = ['break', 'continue', 'return'] # These trigger a dedent when entered, but then count +1 # This might be better than putting 'else' in both # _indenting_statements and _keyword_dedenting_keywords # Don't count 'esac' as a dedenter because case stmts need to get # indented with ")" and ";;" _keyword_dedenting_keywords = ['done', 'fi', 'else', 'then', 'do'] searchURL = "http://www.gnu.org/software/bash/manual/html_node" sample = """# build our tags file find src \( \( -name '*.h' \) -o \\ \( -name '*.cpp' \) -o \\ \( -name '*.c' \) -o \\ \( -name '*.cxx' \) -o \\ -exec ls -1 `pwd`/{} \; | sed -e 's@/cygdrive/c@c:@' -e 's@/\./@/@' | perl -n -e 'chomp; printf(qq(%c%c%s,1%c), 12, 10, $_, 10);' > TAGS """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _indent_styles = [sci_constants.SCE_SH_OPERATOR], _variable_styles = [sci_constants.SCE_SH_IDENTIFIER, sci_constants.SCE_SH_SCALAR], _lineup_close_styles = [sci_constants.SCE_SH_OPERATOR], _lineup_styles = [sci_constants.SCE_SH_OPERATOR], _multiline_styles = [sci_constants.SCE_SH_STRING, sci_constants.SCE_SH_CHARACTER], _keyword_styles = [sci_constants.SCE_SH_WORD], _default_styles = [sci_constants.SCE_SH_DEFAULT], _ignorable_styles = [sci_constants.SCE_SH_ERROR, sci_constants.SCE_SH_COMMENTLINE, sci_constants.SCE_SH_NUMBER], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(sci_constants.SCLEX_BASH) self._lexer.setKeywords(0, self.bash_keywords1 + self.bash_keywords2) self._lexer.supportsFolding = 1 return self._lexer bash_keywords1="""alias ar asa awk banner basename bash bc bdiff break bunzip2 bzip2 cal calendar case cat cc cd chmod cksum clear cmp col comm compress continue cp cpio crypt csplit ctags cut date dc dd declare deroff dev df diff diff3 dircmp dirname do done du echo ed egrep elif else env esac eval ex exec exit expand export expr false fc fgrep fi file find fmt fold for function functions getconf getopt getopts grep gres hash head help history iconv id if in integer jobs join kill local lc let line ln logname look ls m4 mail mailx make man mkdir more mt mv newgrp nl nm nohup ntps od pack paste patch pathchk pax pcat perl pg pr print printf ps pwd read readonly red return rev rm rmdir sed select set sh shift size sleep sort spell split start stop strings strip stty sum suspend sync tail tar tee test then time times touch tr trap true tsort tty type typeset ulimit umask unalias uname uncompress unexpand uniq unpack unset until uudecode uuencode vi vim vpax wait wc whence which while who wpaste wstart xargs zcat""".split() bash_keywords2="""chgrp chown chroot dir dircolors factor groups hostid install link md5sum mkfifo mknod nice pinky printenv ptx readlink seq sha1sum shred stat su tac unlink users vdir whoami yes""".split()
class koLuaLanguage(KoLanguageKeywordBase): name = "Lua" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{D3C94E8B-B75C-4fa4-BC4D-986F68ACD33C}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".lua" commentDelimiterInfo = { "line": [ "--" ], "block": [ ("--[[", "]]") ], } supportsSmartIndent = "keyword" _indenting_statements = ['function', 'if', 'for', 'repeat', 'while', 'else', 'elseif', 'do'] _dedenting_statements = ['break', 'return', 'error'] # These trigger a dedent when entered, but then count +1 # This might be better than putting 'else' in both # _indenting_statements and _keyword_dedenting_keywords _keyword_dedenting_keywords = ['end', 'else', 'elseif', 'until'] sample = """require "lfs" function dirtree(dir) assert(dir and dir ~= "", "directory parameter is missing or empty") if string.sub(dir, -1) == "/" then dir=string.sub(dir, 1, -2) end local diriters = {lfs.dir(dir)} local dirs = {dir} return function() repeat local entry = diriters[#diriters]() if entry then if entry ~= "." and entry ~= ".." then local filename = table.concat(dirs, "/").."/"..entry local attr = lfs.attributes(filename) if attr.mode == "directory" then table.insert(dirs, entry) table.insert(diriters, lfs.dir(filename)) end return filename, attr end else table.remove(dirs) table.remove(diriters) end until #diriters==0 end end """ def __init__(self): KoLanguageKeywordBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC], _indent_styles = [sci_constants.SCE_LUA_OPERATOR], _variable_styles = [sci_constants.SCE_LUA_IDENTIFIER], _lineup_close_styles = [sci_constants.SCE_LUA_OPERATOR], _lineup_styles = [sci_constants.SCE_LUA_OPERATOR], _keyword_styles = [sci_constants.SCE_LUA_WORD, sci_constants.SCE_LUA_WORD2, sci_constants.SCE_LUA_WORD3, sci_constants.SCE_LUA_WORD4, sci_constants.SCE_LUA_WORD5, sci_constants.SCE_LUA_WORD6, sci_constants.SCE_LUA_WORD7, sci_constants.SCE_LUA_WORD8, ], _default_styles = [sci_constants.SCE_LUA_DEFAULT], _ignorable_styles = [sci_constants.SCE_LUA_COMMENT, sci_constants.SCE_LUA_COMMENTLINE, sci_constants.SCE_LUA_COMMENTDOC, sci_constants.SCE_LUA_NUMBER], ) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_LUA) self._lexer.setKeywords(0, self._keywords) self._lexer.setKeywords(1, self._keywords1) self._lexer.supportsFolding = 1 return self._lexer # Reserved words. _keywords = ["and", "break", "do", "else", "elseif", "end", "false", "for", "function", "goto", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while"] # Global functions and constants, and libraries. _keywords1 = ["assert", "collectgarbage", "dofile", "error", "getmetatable", "ipairs", "load", "loadfile", "next", "pairs", "pcall", "print", "rawequal", "rawget", "rawset", "require", "select", "setmetatable", "tonumber", "tostring", "type", "xpcall", "_G", "_VERSION", # New in Lua 5.2. "rawlen", "_ENV", # Deprecated in 5.2. "getfenv", "loadstring", "module", "setfenv", "unpack" "string", "string.byte", "string.char", "string.dump", "string.find", "string.format", "string.gmatch", "string.gsub", "string.len", "string.lower", "string.match", "string.rep", "string.reverse", "string.sub", "string.upper", # New in Lua 5.3. "string.pack", "string.packsize", "string.unpack", "table", "table.concat", "table.insert", "table.remove", "table.sort", # New in 5.2. "table.pack", "table.unpack", # New in in 5.3. "table.move", "math", "math.abs", "math.acos", "math.asin", "math.atan", "math.ceil", "math.cos", "math.deg", "math.exp", "math.floor", "math.fmod", "math.huge", "math.log", "math.max", "math.min", "math.modf", "math.pi", "math.rad", "math.random", "math.randomseed", "math.sin", "math.sqrt", "math.tan", # New in 5.3. "math.maxinteger", "math.mininteger", "math.tointeger", "math.type", "math.ult", "coroutine", "coroutine.create", "coroutine.resume", "coroutine.running", "coroutine.status", "coroutine.wrap", "coroutine.yield", # New in Lua 5.3. "coroutine.isyieldable", "package", "package.cpath", "package.loaded", "package.loadlib", "package.path", "package.preload", # New in 5.2. "package.config", "package.searchers", "package.searchpath", "utf8", "utf8.char", "utf8.charpattern", "utf8.codepoint", "utf8.codes", "utf8.len", "utf8.offset", "io", "io.close", "io.flush", "io.input", "io.lines", "io.open", "io.output", "io.popen", "io.read", "io.stderr", "io.stdin", "io.stdout", "io.tmpfile", "io.type", "io.write", "os", "os.clock", "os.date", "os.difftime", "os.execute", "os.exit", "os.getenv", "os.remove", "os.rename", "os.setlocale", "os.time", "os.tmpname", "debug", "debug.debug", "debug.gethook", "debug.getinfo", "debug.getlocal", "debug.getmetatable", "debug.getregistry", "debug.getupvalue", "debug.sethook", "debug.setlocal", "debug.setmetatable", "debug.setupvalue", "debug.traceback", # New in Lua 5.2. "debug.getuservalue", "debug.setuservalue", "debug.upvalueid", "debug.upvaluejoin"] #XXX: Override _indentingOrDedentingStatement looking for things like # return function ... # Override: # Handle return ... function differently def computeIndent(self, scimoz, indentStyle, continueComments): if continueComments: return KoLanguageKeywordBase.computeIndent(self, scimoz, indentStyle, continueComments) calculatedData = self.getTokenDataForComputeIndent(scimoz, self._style_info) indent = self._computeIndent(scimoz, indentStyle, continueComments, self._style_info, calculatedData) if indent is not None: return indent return KoLanguageKeywordBase.computeIndent(self, scimoz, indentStyle, continueComments, calculatedData=calculatedData) def _computeIndent(self, scimoz, indentStyle, continueComments, style_info, calculatedData): non_ws_tokens = calculatedData['non_ws_tokens'] if not self._lookingAtReturnFunction(non_ws_tokens, style_info): return None tok0 = calculatedData['tokens'][0] if tok0.style in style_info._default_styles: currWSLen = len(tok0.text.expandtabs(scimoz.tabWidth)) newWSLen = currWSLen + scimoz.indent else: newWSLen = scimoz.indent return scimozindent.makeIndentFromWidth(scimoz, newWSLen) def _lookingAtReturnFunction(self, non_ws_tokens, style_info): return (len(non_ws_tokens) >= 2 and non_ws_tokens[0].style in style_info._keyword_styles and non_ws_tokens[0].text == "return" and non_ws_tokens[1].style in style_info._keyword_styles and non_ws_tokens[1].text == "function")
class koGoLanguage(KoLanguageBase, KoLanguageBaseDedentMixin): name = "Go" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{2d6ed8b6-f079-441a-8b5a-10ef781cb989}" _reg_categories_ = [("komodo-language", name)] modeNames = ['go'] primary = 1 internal = 0 accessKey = 'g' defaultExtension = ".go" commentDelimiterInfo = { "line": [ "//" ], "block": [ ("/*", "*/") ], "markup": "*", } _dedenting_statements = [u'goto', u'return', u'break', u'continue'] namedBlockRE = "^[ \t]*?(func\s+(?:\(.*?\)\s*)?\w|package\s+\w)" namedBlockDescription = 'Go functions, methods and packages' supportsSmartIndent = "brace" # The following sample contains embedded tabs because that's the Go way. sample = r"""\ package commands import ( "encoding/json" ) type Filters []string func (f *Filters) String() string { a := "a string" b := 'c' // a char c := 43 // a num return fmt.Sprint(*f) } /* Block comment on these two lines */ """ def __init__(self): KoLanguageBase.__init__(self) self._style_info.update( _block_comment_styles = [sci_constants.SCE_C_COMMENT, sci_constants.SCE_C_COMMENTDOC, sci_constants.SCE_C_COMMENTDOCKEYWORD, sci_constants.SCE_C_COMMENTDOCKEYWORDERROR], _variable_styles = [components.interfaces.ISciMoz.SCE_C_IDENTIFIER] ) self._setupIndentCheckSoftChar() self._fastCharData = \ FastCharData(trigger_char=";", style_list=(sci_constants.SCE_C_OPERATOR,), skippable_chars_by_style={ sci_constants.SCE_C_OPERATOR : "])",}, for_check=True) # And add the new default prefs if they don't exist globalPrefs = components.classes["@activestate.com/koPrefService;1"]\ .getService(components.interfaces.koIPrefService).prefs # Chunk adding prefs based on which ones they were added with. if not globalPrefs.hasPref("gocodeDefaultLocation"): globalPrefs.setStringPref("gocodeDefaultLocation", "") if not globalPrefs.hasPref("godefDefaultLocation"): globalPrefs.setStringPref("godefDefaultLocation", "") if not globalPrefs.hasPref("golangDefaultLocation"): globalPrefs.setStringPref("golangDefaultLocation", "") globalPrefs.setStringPref("Go/newEncoding", "utf-8") globalPrefs.setLongPref("Go/indentWidth", 8) globalPrefs.setBooleanPref("Go/useTabs", True) #TODO: Add formatter prefs along the lines of: # <!-- Go formatter --> # <preference-set > # <string id="formatter_name">generic</string> # <string id="lang">Go</string> # <string id="name">Go Reformatter</string> # <string id="uuid">{286d5b45-a54e-4317-b3c8-da4dc35673a4}</string> # </preference-set> def getLanguageService(self, iid): return KoLanguageBase.getLanguageService(self, iid) def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CPP) self._lexer.supportsFolding = 1 self._lexer.setProperty('lexer.cpp.allow.dollars', '0') self._lexer.setProperty('fold.cpp.syntax.based', '1') self._lexer.setProperty('lexer.cpp.backquoted.strings', '1') self._lexer.setKeywords(0, GoLangInfo.reserved_keywords) # The CPP lexer reserves keywords(2) for comment doc keywords and # keywords(3) for "SCE_C_GLOBALCLASS", so treat the # predeclared_identifiers (like 'bool') and # the predefined_functions (like 'append') as the same. other_words = (GoLangInfo.predeclared_identifiers. union(GoLangInfo.predeclared_functions)) self._lexer.setKeywords(1, other_words) return self._lexer
class koErlangLanguage(KoLanguageBase): name = "Erlang" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" \ % (name) _reg_clsid_ = "{0153c47a-f668-41d4-8519-9ecd6b1c5ba0}" _reg_categories_ = [("komodo-language", name)] _stateMap = { 'default': ('SCE_ERLANG_DEFAULT', ), 'comments': ( 'SCE_ERLANG_COMMENT', 'SCE_ERLANG_COMMENT_FUNCTION', 'SCE_ERLANG_COMMENT_MODULE', 'SCE_ERLANG_COMMENT_DOC', 'SCE_ERLANG_COMMENT_DOC_MACRO', ), 'variables': ('SCE_ERLANG_VARIABLE', ), 'numbers': ('SCE_ERLANG_NUMBER', ), 'keywords': ('SCE_ERLANG_KEYWORD', ), 'strings': ( 'SCE_ERLANG_STRING', 'SCE_ERLANG_CHARACTER', ), 'operators': ('SCE_ERLANG_OPERATOR', ), 'functions': ('SCE_ERLANG_FUNCTION_NAME', ), 'macros': ('SCE_ERLANG_MACRO', ), 'records': ('SCE_ERLANG_RECORD', ), 'atoms': ('SCE_ERLANG_ATOM', ), 'nodes': ('SCE_ERLANG_NODE_NAME', ), 'unknown': ('SCE_ERLANG_UNKNOWN', ), } defaultExtension = '.erl' commentDelimiterInfo = { "line": ["%"], } sample = """-module(test). -export([fac/1]). fac(0) -> 1; fac(N) -> N * fac(N-1). """ def __init__(self): KoLanguageBase.__init__(self) self._fastCharData = \ ErlangFastCharData(trigger_char=".", style_list=(sci_constants.SCE_ERLANG_OPERATOR,), skippable_chars_by_style={ sci_constants.SCE_ERLANG_OPERATOR : "])", }) _keywords = """ after begin case catch cond end fun if let of query receive when define record export import include include_lib ifdef ifndef else endif undef apply attribute call do in letrec module primop try""".split() def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_ERLANG) self._lexer.setKeywords(0, self._keywords) return self._lexer
class koCMakeLanguage(KoLanguageBase): name = "CMake" _reg_desc_ = "%s Language" % name _reg_contractid_ = "@activestate.com/koLanguage?language=%s;1" % (name) _reg_clsid_ = "{6d6fc84a-1bcf-4dac-af4d-dc5ddde8317b}" _reg_categories_ = [("komodo-language", name)] defaultExtension = ".cmake" commentDelimiterInfo = { "line": [ "#" ], } # Sample file. sample = """ set (PRJ ${DESKTOP}/common ) set (FILELIST ${PRJ}/src/source.txt ) message(STATUS "SYSTEM_NAME : ${CMAKE_SYSTEM_NAME}") project(project_name) include_directories( ${PRJ}/src ${PRJ}/includes ) # Load SRC Variable from file file(READ ${FILELIST} SRC) string(REGEX REPLACE "#.*$" "" SRC ${SRC}) string(REPLACE "\n" ";" SRC ${SRC}) add_executable(${PROJECT_NAME} ${SRC} ) foreach (f ${SRC}) set_source_files_properties(${f} PROPERTIES LANGUAGE CXX) endforeach(f) """ # Commands: cmake_commands = [ "add_custom_command", "add_custom_target", "add_definitions", "add_dependencies", "add_executable", "add_library", "add_subdirectory", "add_test", "aux_source_directory", "build_command", "build_name", "cmake_minimum_required", "configure_file", "create_test_sourcelist", "else", "elseif", "enable_language", "enable_testing", "endforeach", "endif", "endmacro", "endwhile", "exec_program", "execute_process", "export_library_dependencies", "file", "find_file", "find_library", "find_package", "find_path", "find_program", "fltk_wrap_ui", "foreach", "get_cmake_property", "get_directory_property", "get_filename_component", "get_source_file_property", "get_target_property", "get_test_property", "if", "include", "include_directories", "include_external_msproject", "include_regular_expression", "install", "install_files", "install_programs", "install_targets", "link_directories", "link_libraries", "list", "load_cache", "load_command", "macro", "make_directory", "mark_as_advanced", "math", "message", "option", "output_required_files", "project", "qt_wrap_cpp", "qt_wrap_ui", "remove", "remove_definitions", "separate_arguments", "set", "set_directory_properties", "set_source_files_properties", "set_target_properties", "set_tests_properties", "site_name", "source_group", "string", "subdir_depends", "subdirs", "target_link_libraries", "try_compile", "try_run", "use_mangled_mesa", "utility_source", "variable_requires", "vtk_make_instantiator", "vtk_wrap_java", "vtk_wrap_python", "vtk_wrap_tcl", "while", "write_file", ] # Variables: cmake_variables = [ "ABSOLUTE", "ABSTRACT", "ADDITIONAL_MAKE_CLEAN_FILES", "ALL", "AND", "APPEND", "ARGS", "ASCII", "BEFORE", "CACHE", "CACHE_VARIABLES", "CLEAR", "COMMAND", "COMMANDS", "COMMAND_NAME", "COMMENT", "COMPARE", "COMPILE_FLAGS", "COPYONLY", "DEFINED", "DEFINE_SYMBOL", "DEPENDS", "DOC", "EQUAL", "ESCAPE_QUOTES", "EXCLUDE", "EXCLUDE_FROM_ALL", "EXISTS", "EXPORT_MACRO", "EXT", "EXTRA_INCLUDE", "FATAL_ERROR", "FILE", "FILES", "FORCE", "FUNCTION", "GENERATED", "GLOB", "GLOB_RECURSE", "GREATER", "GROUP_SIZE", "HEADER_FILE_ONLY", "HEADER_LOCATION", "IMMEDIATE", "INCLUDES", "INCLUDE_DIRECTORIES", "INCLUDE_INTERNALS", "INCLUDE_REGULAR_EXPRESSION", "LESS", "LINK_DIRECTORIES", "LINK_FLAGS", "LOCATION", "MACOSX_BUNDLE", "MACROS", "MAIN_DEPENDENCY", "MAKE_DIRECTORY", "MATCH", "MATCHALL", "MATCHES", "MODULE", "NAME", "NAME_WE", "NOT", "NOTEQUAL", "NO_SYSTEM_PATH", "OBJECT_DEPENDS", "OPTIONAL", "OR", "OUTPUT", "OUTPUT_VARIABLE", "PATH", "PATHS", "POST_BUILD", "POST_INSTALL_SCRIPT", "PREFIX", "PREORDER", "PRE_BUILD", "PRE_INSTALL_SCRIPT", "PRE_LINK", "PROGRAM", "PROGRAM_ARGS", "PROPERTIES", "QUIET", "RANGE", "READ", "REGEX", "REGULAR_EXPRESSION", "REPLACE", "REQUIRED", "RETURN_VALUE", "RUNTIME_DIRECTORY", "SEND_ERROR", "SHARED", "SOURCES", "STATIC", "STATUS", "STREQUAL", "STRGREATER", "STRLESS", "SUFFIX", "TARGET", "TOLOWER", "TOUPPER", "VAR", "VARIABLES", "VERSION", "WIN32", "WRAP_EXCLUDE", "WRITE", # Platform specifics. "APPLE", "MINGW", "MSYS", "CYGWIN", "BORLAND", "WATCOM", "MSVC", "MSVC_IDE", "MSVC60", "MSVC70", "MSVC71", "MSVC80", "CMAKE_COMPILER_2005", "OFF", "ON", ] def get_lexer(self): if self._lexer is None: # Initialize styling information. cmake_style_map = { 'default': ('SCE_CMAKE_DEFAULT',), 'comments': ('SCE_CMAKE_COMMENT',), 'keywords': ('SCE_CMAKE_COMMANDS',), 'keywords2': ('SCE_CMAKE_PARAMETERS',), 'variables': ('SCE_CMAKE_VARIABLE', 'SCE_CMAKE_STRINGVAR'), 'strings': ('SCE_CMAKE_STRINGDQ', 'SCE_CMAKE_STRINGLQ', 'SCE_CMAKE_STRINGRQ'), 'numbers': ('SCE_CMAKE_NUMBER',), 'macro': ('SCE_CMAKE_MACRODEF',), 'section': ('SCE_CMAKE_WHILEDEF', 'SCE_CMAKE_FOREACHDEF', 'SCE_CMAKE_IFDEFINEDEF'), 'user': ('SCE_CMAKE_USERDEFINED',), } # Set style mapping. import styles styles.addSharedStyles(cmake_style_map) styles.StateMap[self.name] = cmake_style_map # Initalize the lexer. self._lexer = KoLexerLanguageService() self._lexer.setLexer(components.interfaces.ISciMoz.SCLEX_CMAKE) self._lexer.setKeywords(0, self.cmake_commands) self._lexer.setKeywords(1, self.cmake_variables) return self._lexer
class basicBase(KoCommonBasicLanguageService): _keywords = None _keywords2 = None sciMozLexer = None commentDelimiterInfo = { "line": ["'", "rem ", "REM "], } _stateMap = { 'default': ('SCE_B_DEFAULT', ), 'keywords': ( 'SCE_B_KEYWORD', 'SCE_B_KEYWORD2', 'SCE_B_KEYWORD3', 'SCE_B_KEYWORD4', ), 'identifiers': ('SCE_B_IDENTIFIER', ), 'comments': ('SCE_B_COMMENT', ), 'numbers': ('SCE_B_NUMBER', ), 'strings': ('SCE_B_STRING', ), 'stringeol': ('SCE_B_STRINGEOL', ), 'operators': ('SCE_B_OPERATOR', ), 'preprocessor': ('SCE_B_PREPROCESSOR', ), 'date': ('SCE_B_DATE', ), 'constants': ('SCE_B_CONSTANT', ), 'assembly': ('SCE_B_ASM', ), } sample = """ INPUT "What is your name"; UserName$ PRINT "Hello "; UserName$ DO INPUT "How many stars do you want"; NumStars Stars$ = "" Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC --or-- Stars$ = STRING$(NumStars, "*") ' <- MS BASIC PRINT Stars$ DO INPUT "Do you want more stars"; Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1); LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Goodbye "; FOR I = 1 TO 200 PRINT UserName$; " "; NEXT I PRINT """ def __init__(self): KoCommonBasicLanguageService.__init__(self) del self.matchingSoftChars["'"] def get_lexer(self): if self._lexer is None: self._lexer = KoLexerLanguageService() self._lexer.setLexer(self.sciMozLexer) self._lexer.setKeywords(0, self._keywords) if self._keywords2: self._lexer.setKeywords(1, self._keywords2) self._lexer.supportsFolding = 1 return self._lexer