tmpok_q575y/0000700000175000017500000000000014773617157012542 5ustar gusnangusnantmpok_q575y/lexilla/0000775000175000017500000000000014773617157014210 5ustar gusnangusnantmpok_q575y/lexilla/access/0000775000175000017500000000000014773064066015444 5ustar gusnangusnantmpok_q575y/lexilla/access/LexillaAccess.cxx0000664000175000017500000001725514773064066020716 0ustar gusnangusnan// SciTE - Scintilla based Text Editor /** @file LexillaAccess.cxx ** Interface to loadable lexers. ** Maintains a list of lexer library paths and CreateLexer functions. ** If list changes then load all the lexer libraries and find the functions. ** When asked to create a lexer, call each function until one succeeds. **/ // Copyright 2019 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #if !defined(_WIN32) #include #else #include #endif #include "ILexer.h" #include "Lexilla.h" #include "LexillaAccess.h" namespace { #if defined(_WIN32) using Function = FARPROC; using Module = HMODULE; constexpr const char *pathSeparator = "\\"; #else using Function = void *; using Module = void *; constexpr const char *pathSeparator = "/"; #endif /// Generic function to convert from a Function(void* or FARPROC) to a function pointer. /// This avoids undefined and conditionally defined behaviour. template T FunctionPointer(Function function) noexcept { static_assert(sizeof(T) == sizeof(function)); T fp {}; memcpy(&fp, &function, sizeof(T)); return fp; } #if defined(_WIN32) std::wstring WideStringFromUTF8(std::string_view sv) { const int sLength = static_cast(sv.length()); const int cchWide = ::MultiByteToWideChar(CP_UTF8, 0, sv.data(), sLength, nullptr, 0); std::wstring sWide(cchWide, 0); ::MultiByteToWideChar(CP_UTF8, 0, sv.data(), sLength, sWide.data(), cchWide); return sWide; } #endif // Turn off deprecation checks as LexillaAccess deprecates its wrapper over // the deprecated LexerNameFromID. Thus use within LexillaAccess is intentional. #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #else #pragma warning(disable: 4996) #endif std::string directoryLoadDefault; std::string lastLoaded; struct LexLibrary { Lexilla::CreateLexerFn fnCL; Lexilla::LexerNameFromIDFn fnLNFI; Lexilla::GetLibraryPropertyNamesFn fnGLPN; Lexilla::SetLibraryPropertyFn fnSLP; std::string nameSpace; }; std::vector libraries; std::vector lexers; std::vector libraryProperties; Function FindSymbol(Module m, const char *symbol) noexcept { #if defined(_WIN32) return ::GetProcAddress(m, symbol); #else return dlsym(m, symbol); #endif } Lexilla::CreateLexerFn pCreateLexerDefault = nullptr; bool NameContainsDot(std::string_view path) noexcept { for (std::string_view::const_reverse_iterator it = path.crbegin(); it != path.crend(); ++it) { if (*it == '.') return true; if (*it == '/' || *it == '\\') return false; } return false; } constexpr bool HasPrefix(std::string_view s, std::string_view prefix) noexcept { return (s.size() >= prefix.size()) && (prefix == s.substr(0, prefix.size())); } } void Lexilla::SetDefault(CreateLexerFn pCreate) noexcept { pCreateLexerDefault = pCreate; } void Lexilla::SetDefaultDirectory(std::string_view directory) { directoryLoadDefault = directory; } bool Lexilla::Load(std::string_view sharedLibraryPaths) { if (sharedLibraryPaths == lastLoaded) { return !libraries.empty(); } std::string_view paths = sharedLibraryPaths; lexers.clear(); libraries.clear(); while (!paths.empty()) { const size_t separator = paths.find_first_of(';'); std::string path(paths.substr(0, separator)); if (separator == std::string::npos) { paths.remove_prefix(paths.size()); } else { paths.remove_prefix(separator + 1); } if (path == ".") { if (directoryLoadDefault.empty()) { path = ""; } else { path = directoryLoadDefault; path += pathSeparator; } path += LEXILLA_LIB; } if (!NameContainsDot(path)) { // No '.' in name so add extension path.append(LEXILLA_EXTENSION); } #if defined(_WIN32) // Convert from UTF-8 to wide characters std::wstring wsPath = WideStringFromUTF8(path); Module lexillaDL = ::LoadLibraryW(wsPath.c_str()); #else Module lexillaDL = dlopen(path.c_str(), RTLD_LAZY); #endif if (lexillaDL) { GetLexerCountFn fnLexerCount = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_GETLEXERCOUNT)); GetLexerNameFn fnLexerName = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_GETLEXERNAME)); if (fnLexerCount && fnLexerName) { const int nLexers = fnLexerCount(); for (int i = 0; i < nLexers; i++) { constexpr size_t lengthName = 200; char name[lengthName]{}; fnLexerName(i, name, sizeof(name)); lexers.emplace_back(name); } } CreateLexerFn fnCL = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_CREATELEXER)); LexerNameFromIDFn fnLNFI = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_LEXERNAMEFROMID)); GetLibraryPropertyNamesFn fnGLPN = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_GETLIBRARYPROPERTYNAMES)); SetLibraryPropertyFn fnSLP = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_SETLIBRARYPROPERTY)); GetNameSpaceFn fnGNS = FunctionPointer( FindSymbol(lexillaDL, LEXILLA_GETNAMESPACE)); std::string nameSpace; if (fnGNS) { nameSpace = fnGNS(); nameSpace += LEXILLA_NAMESPACE_SEPARATOR; } LexLibrary lexLib { fnCL, fnLNFI, fnGLPN, fnSLP, nameSpace }; libraries.push_back(lexLib); } } lastLoaded = sharedLibraryPaths; std::set nameSet; for (const LexLibrary &lexLib : libraries) { if (lexLib.fnGLPN) { const char *cpNames = lexLib.fnGLPN(); if (cpNames) { std::string_view names = cpNames; while (!names.empty()) { const size_t separator = names.find_first_of('\n'); std::string name(names.substr(0, separator)); nameSet.insert(name); if (separator == std::string::npos) { names.remove_prefix(names.size()); } else { names.remove_prefix(separator + 1); } } } } } // Standard Lexilla does not have any properties so can't be added to set. libraryProperties = std::vector(nameSet.begin(), nameSet.end()); return !libraries.empty(); } Scintilla::ILexer5 *Lexilla::MakeLexer(std::string_view languageName) { std::string sLanguageName(languageName); // Ensure NUL-termination // First, try to match namespace then name suffix for (const LexLibrary &lexLib : libraries) { if (lexLib.fnCL && !lexLib.nameSpace.empty()) { if (HasPrefix(languageName, lexLib.nameSpace)) { Scintilla::ILexer5 *pLexer = lexLib.fnCL(sLanguageName.substr(lexLib.nameSpace.size()).c_str()); if (pLexer) { return pLexer; } } } } // If no match with namespace, try to just match name for (const LexLibrary &lexLib : libraries) { if (lexLib.fnCL) { Scintilla::ILexer5 *pLexer = lexLib.fnCL(sLanguageName.c_str()); if (pLexer) { return pLexer; } } } if (pCreateLexerDefault) { return pCreateLexerDefault(sLanguageName.c_str()); } #if defined(LEXILLA_STATIC) Scintilla::ILexer5 *pLexer = CreateLexer(sLanguageName.c_str()); if (pLexer) { return pLexer; } #endif return nullptr; } std::vector Lexilla::Lexers() { return lexers; } std::string Lexilla::NameFromID(int identifier) { for (const LexLibrary &lexLib : libraries) { if (lexLib.fnLNFI) { const char *name = lexLib.fnLNFI(identifier); if (name) { return name; } } } return {}; } std::vector Lexilla::LibraryProperties() { return libraryProperties; } void Lexilla::SetProperty(const char *key, const char *value) { for (const LexLibrary &lexLib : libraries) { if (lexLib.fnSLP) { lexLib.fnSLP(key, value); } } // Standard Lexilla does not have any properties so don't set. } tmpok_q575y/lexilla/access/LexillaAccess.h0000664000175000017500000000236714773064066020341 0ustar gusnangusnan// SciTE - Scintilla based Text Editor /** @file LexillaAccess.h ** Interface to loadable lexers. ** This does not depend on SciTE code so can be copied out into other projects. **/ // Copyright 2019 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXILLAACCESS_H #define LEXILLAACCESS_H namespace Lexilla { // Directory to load default Lexilla from, commonly the directory of the application. void SetDefaultDirectory(std::string_view directory); // Specify CreateLexer when statically linked so no hard dependency in LexillaAccess // so it doesn't have to be built in two forms - static and dynamic. void SetDefault(CreateLexerFn pCreate) noexcept; // sharedLibraryPaths is a ';' separated list of shared libraries to load. // On Win32 it is treated as UTF-8 and on Unix it is passed to dlopen directly. // Return true if any shared libraries are loaded. bool Load(std::string_view sharedLibraryPaths); Scintilla::ILexer5 *MakeLexer(std::string_view languageName); std::vector Lexers(); [[deprecated]] std::string NameFromID(int identifier); std::vector LibraryProperties(); void SetProperty(const char *key, const char *value); } #endif tmpok_q575y/lexilla/access/README0000664000175000017500000000053214773064066016324 0ustar gusnangusnanREADME for access directory. LexillaAccess is a module that simplifies using multiple libraries that follow the Lexilla protocol. It can be compiled into a Lexilla client application. Applications with complex needs can copy the code and customise it to meet their requirements. This module is not meant to be compiled into Lexilla. tmpok_q575y/lexilla/version.txt0000664000175000017500000000000314773064066016422 0ustar gusnangusnan544tmpok_q575y/lexilla/lexlib/0000775000175000017500000000000014773064066015462 5ustar gusnangusnantmpok_q575y/lexilla/lexlib/WordList.h0000664000175000017500000000247014773064066017405 0ustar gusnangusnan// Scintilla source code edit control /** @file WordList.h ** Hold a list of words. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef WORDLIST_H #define WORDLIST_H namespace Lexilla { /** */ class WordList { // Each word contains at least one character - an empty word acts as sentinel at the end. char **words; char *list; size_t len; bool onlyLineEnds; ///< Delimited by any white space or only line ends int starts[256]; public: explicit WordList(bool onlyLineEnds_ = false) noexcept; // Deleted so WordList objects can not be copied. WordList(const WordList &) = delete; WordList(WordList &&) = delete; WordList &operator=(const WordList &) = delete; WordList &operator=(WordList &&) = delete; ~WordList(); operator bool() const noexcept; bool operator!=(const WordList &other) const noexcept; int Length() const noexcept; void Clear() noexcept; bool Set(const char *s, bool lowerCase=false); bool InList(const char *s) const noexcept; bool InList(const std::string &s) const noexcept; bool InListAbbreviated(const char *s, const char marker) const noexcept; bool InListAbridged(const char *s, const char marker) const noexcept; const char *WordAt(int n) const noexcept; }; } #endif tmpok_q575y/lexilla/lexlib/StringCopy.h0000664000175000017500000000152314773064066017735 0ustar gusnangusnan// Scintilla source code edit control /** @file StringCopy.h ** Safe string copy function which always NUL terminates. ** ELEMENTS macro for determining array sizes. **/ // Copyright 2013 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef STRINGCOPY_H #define STRINGCOPY_H namespace Lexilla { // Safer version of string copy functions like strcpy, wcsncpy, etc. // Instantiate over fixed length strings of both char and wchar_t. // May truncate if source doesn't fit into dest with room for NUL. template void StringCopy(T (&dest)[count], const T* source) { for (size_t i=0; i // The License.txt file describes the conditions under which this software may be distributed. #ifndef DEFAULTLEXER_H #define DEFAULTLEXER_H namespace Lexilla { // A simple lexer with no state class DefaultLexer : public Scintilla::ILexer5 { const char *languageName; int language; const LexicalClass *lexClasses; size_t nClasses; public: DefaultLexer(const char *languageName_, int language_, const LexicalClass *lexClasses_ = nullptr, size_t nClasses_ = 0); virtual ~DefaultLexer(); void SCI_METHOD Release() override; int SCI_METHOD Version() const override; const char * SCI_METHOD PropertyNames() override; int SCI_METHOD PropertyType(const char *name) override; const char * SCI_METHOD DescribeProperty(const char *name) override; Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override; const char * SCI_METHOD DescribeWordListSets() override; Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override; void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override = 0; void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override; void * SCI_METHOD PrivateCall(int operation, void *pointer) override; int SCI_METHOD LineEndTypesSupported() override; int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override; int SCI_METHOD SubStylesStart(int styleBase) override; int SCI_METHOD SubStylesLength(int styleBase) override; int SCI_METHOD StyleFromSubStyle(int subStyle) override; int SCI_METHOD PrimaryStyleFromStyle(int style) override; void SCI_METHOD FreeSubStyles() override; void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override; int SCI_METHOD DistanceToSecondaryStyles() override; const char * SCI_METHOD GetSubStyleBases() override; int SCI_METHOD NamedStyles() override; const char * SCI_METHOD NameOfStyle(int style) override; const char * SCI_METHOD TagsOfStyle(int style) override; const char * SCI_METHOD DescriptionOfStyle(int style) override; // ILexer5 methods const char * SCI_METHOD GetName() override; int SCI_METHOD GetIdentifier() override; }; } #endif tmpok_q575y/lexilla/lexlib/PropSetSimple.cxx0000664000175000017500000000314414773064066020756 0ustar gusnangusnan// Scintilla source code edit control /** @file PropSetSimple.cxx ** A basic string to string map. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. // Maintain a dictionary of properties #include #include #include #include #include #include #include #include "PropSetSimple.h" using namespace Lexilla; namespace { using mapss = std::map>; mapss *PropsFromPointer(void *impl) noexcept { return static_cast(impl); } } PropSetSimple::PropSetSimple() { mapss *props = new mapss; impl = static_cast(props); } PropSetSimple::~PropSetSimple() { mapss *props = PropsFromPointer(impl); delete props; impl = nullptr; } bool PropSetSimple::Set(std::string_view key, std::string_view val) { mapss *props = PropsFromPointer(impl); if (!props) return false; mapss::iterator const it = props->find(key); if (it != props->end()) { if (val == it->second) return false; it->second = val; } else { props->emplace(key, val); } return true; } const char *PropSetSimple::Get(std::string_view key) const { mapss *props = PropsFromPointer(impl); if (props) { mapss::const_iterator const keyPos = props->find(key); if (keyPos != props->end()) { return keyPos->second.c_str(); } } return ""; } int PropSetSimple::GetInt(std::string_view key, int defaultValue) const { const char *val = Get(key); assert(val); if (*val) { return atoi(val); } return defaultValue; } tmpok_q575y/lexilla/lexlib/CharacterCategory.h0000664000175000017500000000247514773064066021235 0ustar gusnangusnan// Scintilla source code edit control /** @file CharacterCategory.h ** Returns the Unicode general category of a character. **/ // Copyright 2013 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef CHARACTERCATEGORY_H #define CHARACTERCATEGORY_H namespace Lexilla { enum CharacterCategory { ccLu, ccLl, ccLt, ccLm, ccLo, ccMn, ccMc, ccMe, ccNd, ccNl, ccNo, ccPc, ccPd, ccPs, ccPe, ccPi, ccPf, ccPo, ccSm, ccSc, ccSk, ccSo, ccZs, ccZl, ccZp, ccCc, ccCf, ccCs, ccCo, ccCn }; CharacterCategory CategoriseCharacter(int character) noexcept; // Common definitions of allowable characters in identifiers from UAX #31. bool IsIdStart(int character) noexcept; bool IsIdContinue(int character) noexcept; bool IsXidStart(int character) noexcept; bool IsXidContinue(int character) noexcept; class CharacterCategoryMap { private: std::vector dense; public: CharacterCategoryMap(); CharacterCategory CategoryFor(int character) const noexcept { if (static_cast(character) < dense.size()) { return static_cast(dense[character]); } else { // binary search through ranges return CategoriseCharacter(character); } } int Size() const noexcept; void Optimize(int countCharacters); }; } #endif tmpok_q575y/lexilla/lexlib/DefaultLexer.cxx0000664000175000017500000000611414773064066020574 0ustar gusnangusnan// Scintilla source code edit control /** @file DefaultLexer.cxx ** A lexer base class that provides reasonable default behaviour. **/ // Copyright 2017 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" #include "PropSetSimple.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" #include "LexerModule.h" #include "DefaultLexer.h" using namespace Lexilla; static const char styleSubable[] = { 0 }; DefaultLexer::DefaultLexer(const char *languageName_, int language_, const LexicalClass *lexClasses_, size_t nClasses_) : languageName(languageName_), language(language_), lexClasses(lexClasses_), nClasses(nClasses_) { } DefaultLexer::~DefaultLexer() = default; void SCI_METHOD DefaultLexer::Release() { delete this; } int SCI_METHOD DefaultLexer::Version() const { return Scintilla::lvRelease5; } const char * SCI_METHOD DefaultLexer::PropertyNames() { return ""; } int SCI_METHOD DefaultLexer::PropertyType(const char *) { return SC_TYPE_BOOLEAN; } const char * SCI_METHOD DefaultLexer::DescribeProperty(const char *) { return ""; } Sci_Position SCI_METHOD DefaultLexer::PropertySet(const char *, const char *) { return -1; } const char * SCI_METHOD DefaultLexer::DescribeWordListSets() { return ""; } Sci_Position SCI_METHOD DefaultLexer::WordListSet(int, const char *) { return -1; } void SCI_METHOD DefaultLexer::Fold(Sci_PositionU, Sci_Position, int, Scintilla::IDocument *) { } void * SCI_METHOD DefaultLexer::PrivateCall(int, void *) { return nullptr; } int SCI_METHOD DefaultLexer::LineEndTypesSupported() { return SC_LINE_END_TYPE_DEFAULT; } int SCI_METHOD DefaultLexer::AllocateSubStyles(int, int) { return -1; } int SCI_METHOD DefaultLexer::SubStylesStart(int) { return -1; } int SCI_METHOD DefaultLexer::SubStylesLength(int) { return 0; } int SCI_METHOD DefaultLexer::StyleFromSubStyle(int subStyle) { return subStyle; } int SCI_METHOD DefaultLexer::PrimaryStyleFromStyle(int style) { return style; } void SCI_METHOD DefaultLexer::FreeSubStyles() { } void SCI_METHOD DefaultLexer::SetIdentifiers(int, const char *) { } int SCI_METHOD DefaultLexer::DistanceToSecondaryStyles() { return 0; } const char * SCI_METHOD DefaultLexer::GetSubStyleBases() { return styleSubable; } int SCI_METHOD DefaultLexer::NamedStyles() { return static_cast(nClasses); } const char * SCI_METHOD DefaultLexer::NameOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].name : ""; } const char * SCI_METHOD DefaultLexer::TagsOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].tags : ""; } const char * SCI_METHOD DefaultLexer::DescriptionOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].description : ""; } // ILexer5 methods const char * SCI_METHOD DefaultLexer::GetName() { return languageName; } int SCI_METHOD DefaultLexer::GetIdentifier() { return language; } tmpok_q575y/lexilla/lexlib/LexerSimple.h0000664000175000017500000000166314773064066020072 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerSimple.h ** A simple lexer with no state. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXERSIMPLE_H #define LEXERSIMPLE_H namespace Lexilla { // A simple lexer with no state class LexerSimple : public LexerBase { const LexerModule *lexerModule; std::string wordLists; public: explicit LexerSimple(const LexerModule *lexerModule_); const char * SCI_METHOD DescribeWordListSets() override; void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override; void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override; // ILexer5 methods const char * SCI_METHOD GetName() override; int SCI_METHOD GetIdentifier() override; }; } #endif tmpok_q575y/lexilla/lexlib/InList.h0000664000175000017500000000100414773064066017030 0ustar gusnangusnan// Scintilla source code edit control /** @file InList.h ** Check if a string is in a list. **/ // Copyright 2024 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef INLIST_H #define INLIST_H namespace Lexilla { bool InList(std::string_view value, std::initializer_list list) noexcept; bool InListCaseInsensitive(std::string_view value, std::initializer_list list) noexcept; } #endif tmpok_q575y/lexilla/lexlib/LexerBase.cxx0000664000175000017500000000636614773064066020073 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerBase.cxx ** A simple lexer with no state. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" #include "PropSetSimple.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" #include "LexerModule.h" #include "LexerBase.h" using namespace Lexilla; static const char styleSubable[] = { 0 }; LexerBase::LexerBase(const LexicalClass *lexClasses_, size_t nClasses_) : lexClasses(lexClasses_), nClasses(nClasses_) { for (int wl = 0; wl < numWordLists; wl++) keyWordLists[wl] = new WordList; keyWordLists[numWordLists] = nullptr; } LexerBase::~LexerBase() { for (int wl = 0; wl < numWordLists; wl++) { delete keyWordLists[wl]; keyWordLists[wl] = nullptr; } keyWordLists[numWordLists] = nullptr; } void SCI_METHOD LexerBase::Release() { delete this; } int SCI_METHOD LexerBase::Version() const { return Scintilla::lvRelease5; } const char * SCI_METHOD LexerBase::PropertyNames() { return ""; } int SCI_METHOD LexerBase::PropertyType(const char *) { return SC_TYPE_BOOLEAN; } const char * SCI_METHOD LexerBase::DescribeProperty(const char *) { return ""; } Sci_Position SCI_METHOD LexerBase::PropertySet(const char *key, const char *val) { if (props.Set(key, val)) { return 0; } else { return -1; } } const char *SCI_METHOD LexerBase::PropertyGet(const char *key) { return props.Get(key); } const char * SCI_METHOD LexerBase::DescribeWordListSets() { return ""; } Sci_Position SCI_METHOD LexerBase::WordListSet(int n, const char *wl) { if (n < numWordLists) { if (keyWordLists[n]->Set(wl)) { return 0; } } return -1; } void * SCI_METHOD LexerBase::PrivateCall(int, void *) { return nullptr; } int SCI_METHOD LexerBase::LineEndTypesSupported() { return SC_LINE_END_TYPE_DEFAULT; } int SCI_METHOD LexerBase::AllocateSubStyles(int, int) { return -1; } int SCI_METHOD LexerBase::SubStylesStart(int) { return -1; } int SCI_METHOD LexerBase::SubStylesLength(int) { return 0; } int SCI_METHOD LexerBase::StyleFromSubStyle(int subStyle) { return subStyle; } int SCI_METHOD LexerBase::PrimaryStyleFromStyle(int style) { return style; } void SCI_METHOD LexerBase::FreeSubStyles() { } void SCI_METHOD LexerBase::SetIdentifiers(int, const char *) { } int SCI_METHOD LexerBase::DistanceToSecondaryStyles() { return 0; } const char * SCI_METHOD LexerBase::GetSubStyleBases() { return styleSubable; } int SCI_METHOD LexerBase::NamedStyles() { return static_cast(nClasses); } const char * SCI_METHOD LexerBase::NameOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].name : ""; } const char * SCI_METHOD LexerBase::TagsOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].tags : ""; } const char * SCI_METHOD LexerBase::DescriptionOfStyle(int style) { return (style < NamedStyles()) ? lexClasses[style].description : ""; } // ILexer5 methods const char *SCI_METHOD LexerBase::GetName() { return ""; } int SCI_METHOD LexerBase::GetIdentifier() { return SCLEX_AUTOMATIC; } tmpok_q575y/lexilla/lexlib/CharacterSet.cxx0000664000175000017500000000254414773064066020563 0ustar gusnangusnan// Scintilla source code edit control /** @file CharacterSet.cxx ** Simple case functions for ASCII. ** Lexer infrastructure. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include "CharacterSet.h" using namespace Lexilla; namespace Lexilla { int CompareCaseInsensitive(const char *a, const char *b) noexcept { while (*a && *b) { if (*a != *b) { const char upperA = MakeUpperCase(*a); const char upperB = MakeUpperCase(*b); if (upperA != upperB) return upperA - upperB; } a++; b++; } // Either *a or *b is nul return *a - *b; } bool EqualCaseInsensitive(std::string_view a, std::string_view b) noexcept { if (a.length() != b.length()) { return false; } for (size_t i = 0; i < a.length(); i++) { if (MakeUpperCase(a[i]) != MakeUpperCase(b[i])) { return false; } } return true; } int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept { while (*a && *b && len) { if (*a != *b) { const char upperA = MakeUpperCase(*a); const char upperB = MakeUpperCase(*b); if (upperA != upperB) return upperA - upperB; } a++; b++; len--; } if (len == 0) return 0; else // Either *a or *b is nul return *a - *b; } } tmpok_q575y/lexilla/lexlib/LexerSimple.cxx0000664000175000017500000000330614773064066020441 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerSimple.cxx ** A simple lexer with no state. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" #include "PropSetSimple.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" #include "LexerModule.h" #include "LexerBase.h" #include "LexerSimple.h" using namespace Lexilla; LexerSimple::LexerSimple(const LexerModule *module_) : LexerBase(module_->LexClasses(), module_->NamedStyles()), lexerModule(module_) { for (int wl = 0; wl < lexerModule->GetNumWordLists(); wl++) { if (!wordLists.empty()) wordLists += "\n"; wordLists += lexerModule->GetWordListDescription(wl); } } const char * SCI_METHOD LexerSimple::DescribeWordListSets() { return wordLists.c_str(); } void SCI_METHOD LexerSimple::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) { Accessor astyler(pAccess, &props); lexerModule->Lex(startPos, lengthDoc, initStyle, keyWordLists, astyler); astyler.Flush(); } void SCI_METHOD LexerSimple::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) { if (props.GetInt("fold")) { Accessor astyler(pAccess, &props); lexerModule->Fold(startPos, lengthDoc, initStyle, keyWordLists, astyler); astyler.Flush(); } } const char * SCI_METHOD LexerSimple::GetName() { return lexerModule->languageName; } int SCI_METHOD LexerSimple::GetIdentifier() { return lexerModule->GetLanguage(); } tmpok_q575y/lexilla/lexlib/InList.cxx0000664000175000017500000000153514773064066017414 0ustar gusnangusnan// Scintilla source code edit control /** @file InList.cxx ** Check if a string is in a list. **/ // Copyright 2024 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include "InList.h" #include "CharacterSet.h" namespace Lexilla { bool InList(std::string_view value, std::initializer_list list) noexcept { for (const std::string_view element : list) { if (value == element) { return true; } } return false; } bool InListCaseInsensitive(std::string_view value, std::initializer_list list) noexcept { for (const std::string_view element : list) { if (EqualCaseInsensitive(value, element)) { return true; } } return false; } } tmpok_q575y/lexilla/lexlib/OptionSet.h0000664000175000017500000001006414773064066017560 0ustar gusnangusnan// Scintilla source code edit control /** @file OptionSet.h ** Manage descriptive information about an options struct for a lexer. ** Hold the names, positions, and descriptions of boolean, integer and string options and ** allow setting options and retrieving metadata about the options. **/ // Copyright 2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef OPTIONSET_H #define OPTIONSET_H namespace Lexilla { template class OptionSet { typedef T Target; typedef bool T::*plcob; typedef int T::*plcoi; typedef std::string T::*plcos; struct Option { int opType; union { plcob pb; plcoi pi; plcos ps; }; std::string value; std::string description; Option() : opType(SC_TYPE_BOOLEAN), pb(nullptr) { } Option(plcob pb_, std::string_view description_="") : opType(SC_TYPE_BOOLEAN), pb(pb_), description(description_) { } Option(plcoi pi_, std::string_view description_) : opType(SC_TYPE_INTEGER), pi(pi_), description(description_) { } Option(plcos ps_, std::string_view description_) : opType(SC_TYPE_STRING), ps(ps_), description(description_) { } bool Set(T *base, const char *val) { value = val; switch (opType) { case SC_TYPE_BOOLEAN: { const bool option = atoi(val) != 0; if ((*base).*pb != option) { (*base).*pb = option; return true; } break; } case SC_TYPE_INTEGER: { const int option = atoi(val); if ((*base).*pi != option) { (*base).*pi = option; return true; } break; } case SC_TYPE_STRING: { if ((*base).*ps != val) { (*base).*ps = val; return true; } break; } default: break; } return false; } const char *Get() const noexcept { return value.c_str(); } }; typedef std::map> OptionMap; OptionMap nameToDef; std::string names; std::string wordLists; void AppendName(const char *name) { if (!names.empty()) names += "\n"; names += name; } public: void DefineProperty(const char *name, plcob pb, std::string_view description="") { nameToDef[name] = Option(pb, description); AppendName(name); } void DefineProperty(const char *name, plcoi pi, std::string_view description="") { nameToDef[name] = Option(pi, description); AppendName(name); } void DefineProperty(const char *name, plcos ps, std::string_view description="") { nameToDef[name] = Option(ps, description); AppendName(name); } template void DefineProperty(const char *name, E T::*pe, std::string_view description="") { static_assert(std::is_enum::value); plcoi pi {}; static_assert(sizeof(pe) == sizeof(pi)); memcpy(&pi, &pe, sizeof(pe)); nameToDef[name] = Option(pi, description); AppendName(name); } const char *PropertyNames() const noexcept { return names.c_str(); } int PropertyType(const char *name) const { typename OptionMap::const_iterator const it = nameToDef.find(name); if (it != nameToDef.end()) { return it->second.opType; } return SC_TYPE_BOOLEAN; } const char *DescribeProperty(const char *name) const { typename OptionMap::const_iterator const it = nameToDef.find(name); if (it != nameToDef.end()) { return it->second.description.c_str(); } return ""; } bool PropertySet(T *base, const char *name, const char *val) { typename OptionMap::iterator const it = nameToDef.find(name); if (it != nameToDef.end()) { return it->second.Set(base, val); } return false; } const char *PropertyGet(const char *name) const { typename OptionMap::const_iterator const it = nameToDef.find(name); if (it != nameToDef.end()) { return it->second.Get(); } return nullptr; } void DefineWordListSets(const char * const wordListDescriptions[]) { if (wordListDescriptions) { for (size_t wl = 0; wordListDescriptions[wl]; wl++) { if (wl > 0) wordLists += "\n"; wordLists += wordListDescriptions[wl]; } } } const char *DescribeWordListSets() const noexcept { return wordLists.c_str(); } }; } #endif tmpok_q575y/lexilla/lexlib/StyleContext.cxx0000664000175000017500000000504614773064066020660 0ustar gusnangusnan// Scintilla source code edit control /** @file StyleContext.cxx ** Lexer infrastructure. **/ // Copyright 1998-2004 by Neil Hodgson // This file is in the public domain. #include #include #include #include #include #include "ILexer.h" #include "LexAccessor.h" #include "Accessor.h" #include "StyleContext.h" #include "CharacterSet.h" using namespace Lexilla; StyleContext::StyleContext(Sci_PositionU startPos, Sci_PositionU length, int initStyle, LexAccessor &styler_, char chMask) : styler(styler_), multiByteAccess((styler.Encoding() == EncodingType::eightBit) ? nullptr : styler.MultiByteAccess()), lengthDocument(static_cast(styler.Length())), endPos(((startPos + length) < lengthDocument) ? (startPos + length) : (lengthDocument+1)), lineDocEnd(styler.GetLine(lengthDocument)), currentPosLastRelative(SIZE_MAX), currentPos(startPos), currentLine(styler.GetLine(startPos)), lineEnd(styler.LineEnd(currentLine)), lineStartNext(styler.LineStart(currentLine + 1)), atLineStart(static_cast(styler.LineStart(currentLine)) == startPos), // Mask off all bits which aren't in the chMask. state(initStyle &chMask) { styler.StartAt(startPos /*, chMask*/); styler.StartSegment(startPos); chPrev = GetRelativeCharacter(-1); // Variable width is now 0 so GetNextChar gets the char at currentPos into chNext/widthNext GetNextChar(); ch = chNext; width = widthNext; GetNextChar(); } bool StyleContext::MatchIgnoreCase(const char *s) { if (MakeLowerCase(ch) != static_cast(*s)) return false; s++; if (!*s) return true; if (MakeLowerCase(chNext) != static_cast(*s)) return false; s++; for (int n = 2; *s; n++) { if (*s != MakeLowerCase(styler.SafeGetCharAt(currentPos + n, 0))) return false; s++; } return true; } void StyleContext::GetCurrent(char *s, Sci_PositionU len) const { styler.GetRange(styler.GetStartSegment(), currentPos, s, len); } void StyleContext::GetCurrentLowered(char *s, Sci_PositionU len) const { styler.GetRangeLowered(styler.GetStartSegment(), currentPos, s, len); } void StyleContext::GetCurrentString(std::string &string, Transform transform) const { const Sci_PositionU startPos = styler.GetStartSegment(); const Sci_PositionU len = currentPos - styler.GetStartSegment(); string.resize(len); if (transform == Transform::lower) { styler.GetRangeLowered(startPos, currentPos, string.data(), len + 1); } else { styler.GetRange(startPos, currentPos, string.data(), len + 1); } } tmpok_q575y/lexilla/lexlib/LexerModule.cxx0000664000175000017500000000602414773064066020435 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerModule.cxx ** Colourise for particular languages. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" #include "PropSetSimple.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" #include "LexerModule.h" #include "LexerBase.h" #include "LexerSimple.h" using namespace Lexilla; LexerModule::LexerModule(int language_, LexerFunction fnLexer_, const char *languageName_, LexerFunction fnFolder_, const char *const wordListDescriptions_[], const LexicalClass *lexClasses_, size_t nClasses_) noexcept : language(language_), fnLexer(fnLexer_), fnFolder(fnFolder_), fnFactory(nullptr), wordListDescriptions(wordListDescriptions_), lexClasses(lexClasses_), nClasses(nClasses_), languageName(languageName_) { } LexerModule::LexerModule(int language_, LexerFactoryFunction fnFactory_, const char *languageName_, const char * const wordListDescriptions_[]) noexcept : language(language_), fnLexer(nullptr), fnFolder(nullptr), fnFactory(fnFactory_), wordListDescriptions(wordListDescriptions_), lexClasses(nullptr), nClasses(0), languageName(languageName_) { } int LexerModule::GetLanguage() const noexcept { return language; } int LexerModule::GetNumWordLists() const noexcept { if (!wordListDescriptions) { return -1; } else { int numWordLists = 0; while (wordListDescriptions[numWordLists]) { ++numWordLists; } return numWordLists; } } const char *LexerModule::GetWordListDescription(int index) const noexcept { assert(index < GetNumWordLists()); if (!wordListDescriptions || (index >= GetNumWordLists())) { return ""; } else { return wordListDescriptions[index]; } } const LexicalClass *LexerModule::LexClasses() const noexcept { return lexClasses; } size_t LexerModule::NamedStyles() const noexcept { return nClasses; } Scintilla::ILexer5 *LexerModule::Create() const { if (fnFactory) return fnFactory(); else return new LexerSimple(this); } void LexerModule::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, WordList *keywordlists[], Accessor &styler) const { if (fnLexer) fnLexer(startPos, lengthDoc, initStyle, keywordlists, styler); } void LexerModule::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, WordList *keywordlists[], Accessor &styler) const { if (fnFolder) { Sci_Position lineCurrent = styler.GetLine(startPos); // Move back one line in case deletion wrecked current line fold state if (lineCurrent > 0) { lineCurrent--; const Sci_Position newStartPos = styler.LineStart(lineCurrent); lengthDoc += startPos - newStartPos; startPos = newStartPos; initStyle = 0; if (startPos > 0) { initStyle = styler.StyleIndexAt(startPos - 1); } } fnFolder(startPos, lengthDoc, initStyle, keywordlists, styler); } } tmpok_q575y/lexilla/lexlib/LexerModule.h0000664000175000017500000000532414773064066020064 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerModule.h ** Colourise for particular languages. **/ // Copyright 1998-2001 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXERMODULE_H #define LEXERMODULE_H namespace Lexilla { class Accessor; class WordList; struct LexicalClass; typedef void (*LexerFunction)(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, WordList *keywordlists[], Accessor &styler); typedef Scintilla::ILexer5 *(*LexerFactoryFunction)(); /** * A LexerModule is responsible for lexing and folding a particular language. * The Catalogue class maintains a list of LexerModules which can be searched to find a * module appropriate to a particular language. * The ExternalLexerModule subclass holds lexers loaded from DLLs or shared libraries. */ class LexerModule { protected: int language; LexerFunction fnLexer; LexerFunction fnFolder; LexerFactoryFunction fnFactory; const char * const * wordListDescriptions; const LexicalClass *lexClasses; size_t nClasses; public: const char *languageName; LexerModule( int language_, LexerFunction fnLexer_, const char *languageName_=nullptr, LexerFunction fnFolder_= nullptr, const char * const wordListDescriptions_[]=nullptr, const LexicalClass *lexClasses_=nullptr, size_t nClasses_=0) noexcept; LexerModule( int language_, LexerFactoryFunction fnFactory_, const char *languageName_, const char * const wordListDescriptions_[]=nullptr) noexcept; int GetLanguage() const noexcept; // -1 is returned if no WordList information is available int GetNumWordLists() const noexcept; const char *GetWordListDescription(int index) const noexcept; const LexicalClass *LexClasses() const noexcept; size_t NamedStyles() const noexcept; Scintilla::ILexer5 *Create() const; void Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, WordList *keywordlists[], Accessor &styler) const; void Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, WordList *keywordlists[], Accessor &styler) const; friend class CatalogueModules; }; constexpr int Maximum(int a, int b) noexcept { return (a > b) ? a : b; } // Shut up annoying Visual C++ warnings: #if defined(_MSC_VER) #pragma warning(disable: 4244 4456 4457) #endif // Turn off shadow warnings for lexers as may be maintained by others #if defined(__GNUC__) #pragma GCC diagnostic ignored "-Wshadow" #endif // Clang doesn't like omitting braces in array initialization but they just add // noise to LexicalClass arrays in lexers #if defined(__clang__) #pragma clang diagnostic ignored "-Wmissing-braces" #endif } #endif tmpok_q575y/lexilla/lexlib/SparseState.h0000664000175000017500000000576214773064066020103 0ustar gusnangusnan// Scintilla source code edit control /** @file SparseState.h ** Hold lexer state that may change rarely. ** This is often per-line state such as whether a particular type of section has been entered. ** A state continues until it is changed. **/ // Copyright 2011 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef SPARSESTATE_H #define SPARSESTATE_H namespace Lexilla { template class SparseState { struct State { Sci_Position position; T value; constexpr State(Sci_Position position_, T value_) noexcept : position(position_), value(std::move(value_)) { } inline bool operator<(const State &other) const noexcept { return position < other.position; } inline bool operator==(const State &other) const noexcept { return (position == other.position) && (value == other.value); } }; Sci_Position positionFirst; typedef std::vector stateVector; stateVector states; typename stateVector::iterator Find(Sci_Position position) { const State searchValue(position, T()); return std::lower_bound(states.begin(), states.end(), searchValue); } public: explicit SparseState(Sci_Position positionFirst_=-1) { positionFirst = positionFirst_; } void Set(Sci_Position position, T value) { Delete(position); if (states.empty() || (value != states[states.size()-1].value)) { states.push_back(State(position, value)); } } T ValueAt(Sci_Position position) { if (states.empty()) return T(); if (position < states[0].position) return T(); typename stateVector::iterator low = Find(position); if (low == states.end()) { return states[states.size()-1].value; } else { if (low->position > position) { --low; } return low->value; } } bool Delete(Sci_Position position) { typename stateVector::iterator low = Find(position); if (low != states.end()) { states.erase(low, states.end()); return true; } return false; } size_t size() const { return states.size(); } // Returns true if Merge caused a significant change bool Merge(const SparseState &other, Sci_Position ignoreAfter) { // Changes caused beyond ignoreAfter are not significant Delete(ignoreAfter+1); bool different = true; bool changed = false; typename stateVector::iterator low = Find(other.positionFirst); if (static_cast(states.end() - low) == other.states.size()) { // Same number in other as after positionFirst in this different = !std::equal(low, states.end(), other.states.begin()); } if (different) { if (low != states.end()) { states.erase(low, states.end()); changed = true; } typename stateVector::const_iterator startOther = other.states.begin(); if (!states.empty() && !other.states.empty() && states.back().value == startOther->value) ++startOther; if (startOther != other.states.end()) { states.insert(states.end(), startOther, other.states.end()); changed = true; } } return changed; } }; } #endif tmpok_q575y/lexilla/lexlib/CatalogueModules.h0000664000175000017500000000336514773064066021077 0ustar gusnangusnan// Scintilla source code edit control /** @file CatalogueModules.h ** Lexer infrastructure. ** Contains a list of LexerModules which can be searched to find a module appropriate for a ** particular language. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef CATALOGUEMODULES_H #define CATALOGUEMODULES_H namespace Lexilla { class CatalogueModules { std::vector lexerCatalogue; public: const LexerModule *Find(int language) const noexcept { for (const LexerModule *lm : lexerCatalogue) { if (lm->GetLanguage() == language) { return lm; } } return nullptr; } const LexerModule *Find(const char *languageName) const noexcept { if (languageName) { for (const LexerModule *lm : lexerCatalogue) { if (lm->languageName && (0 == strcmp(lm->languageName, languageName))) { return lm; } } } return nullptr; } void AddLexerModule(const LexerModule *plm) { lexerCatalogue.push_back(plm); } void AddLexerModules(std::initializer_list modules) { lexerCatalogue.insert(lexerCatalogue.end(), modules); } size_t Count() const noexcept { return lexerCatalogue.size(); } const char *Name(size_t index) const noexcept { if (index < lexerCatalogue.size()) { return lexerCatalogue[index]->languageName; } return ""; } LexerFactoryFunction Factory(size_t index) const noexcept { // Works for object lexers but not for function lexers return lexerCatalogue[index]->fnFactory; } Scintilla::ILexer5 *Create(size_t index) const { const LexerModule *plm = lexerCatalogue[index]; if (!plm) { return nullptr; } return plm->Create(); } }; } #endif tmpok_q575y/lexilla/lexlib/SubStyles.h0000664000175000017500000001213014773064066017565 0ustar gusnangusnan// Scintilla source code edit control /** @file SubStyles.h ** Manage substyles for a lexer. **/ // Copyright 2012 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef SUBSTYLES_H #define SUBSTYLES_H namespace Lexilla { class WordClassifier { int baseStyle; int firstStyle; int lenStyles; using WordStyleMap = std::map>; WordStyleMap wordToStyle; public: explicit WordClassifier(int baseStyle_) : baseStyle(baseStyle_), firstStyle(0), lenStyles(0) { } void Allocate(int firstStyle_, int lenStyles_) noexcept { firstStyle = firstStyle_; lenStyles = lenStyles_; wordToStyle.clear(); } int Base() const noexcept { return baseStyle; } int Start() const noexcept { return firstStyle; } int Last() const noexcept { return firstStyle + lenStyles - 1; } int Length() const noexcept { return lenStyles; } void Clear() noexcept { firstStyle = 0; lenStyles = 0; wordToStyle.clear(); } int ValueFor(std::string_view s) const { WordStyleMap::const_iterator const it = wordToStyle.find(s); if (it != wordToStyle.end()) return it->second; else return -1; } bool IncludesStyle(int style) const noexcept { return (style >= firstStyle) && (style < (firstStyle + lenStyles)); } void RemoveStyle(int style) noexcept { WordStyleMap::iterator it = wordToStyle.begin(); while (it != wordToStyle.end()) { if (it->second == style) { it = wordToStyle.erase(it); } else { ++it; } } } void SetIdentifiers(int style, const char *identifiers, bool lowerCase) { RemoveStyle(style); if (!identifiers) return; while (*identifiers) { const char *cpSpace = identifiers; while (*cpSpace && !(*cpSpace == ' ' || *cpSpace == '\t' || *cpSpace == '\r' || *cpSpace == '\n')) cpSpace++; if (cpSpace > identifiers) { std::string word(identifiers, cpSpace - identifiers); if (lowerCase) { for (char &ch : word) { ch = MakeLowerCase(ch); } } wordToStyle[word] = style; } identifiers = cpSpace; if (*identifiers) identifiers++; } } }; // This is the common configuration: 64 sub-styles allocated from 128 to 191 constexpr int SubStylesFirst = 0x80; constexpr int SubStylesAvailable = 0x40; class SubStyles { int classifications; const char *baseStyles; int styleFirst; int stylesAvailable; int secondaryDistance; int allocated; std::vector classifiers; int BlockFromBaseStyle(int baseStyle) const noexcept { for (int b=0; b < classifications; b++) { if (baseStyle == baseStyles[b]) return b; } return -1; } int BlockFromStyle(int style) const noexcept { int b = 0; for (const WordClassifier &wc : classifiers) { if (wc.IncludesStyle(style)) return b; b++; } return -1; } public: SubStyles(const char *baseStyles_, int styleFirst_=SubStylesFirst, int stylesAvailable_=SubStylesAvailable, int secondaryDistance_=0) : classifications(0), baseStyles(baseStyles_), styleFirst(styleFirst_), stylesAvailable(stylesAvailable_), secondaryDistance(secondaryDistance_), allocated(0) { while (baseStyles[classifications]) { classifiers.push_back(WordClassifier(baseStyles[classifications])); classifications++; } } int Allocate(int styleBase, int numberStyles) noexcept { const int block = BlockFromBaseStyle(styleBase); if (block >= 0) { if ((allocated + numberStyles) > stylesAvailable) return -1; const int startBlock = styleFirst + allocated; allocated += numberStyles; classifiers[block].Allocate(startBlock, numberStyles); return startBlock; } else { return -1; } } int Start(int styleBase) noexcept { const int block = BlockFromBaseStyle(styleBase); return (block >= 0) ? classifiers[block].Start() : -1; } int Length(int styleBase) noexcept { const int block = BlockFromBaseStyle(styleBase); return (block >= 0) ? classifiers[block].Length() : 0; } int BaseStyle(int subStyle) const noexcept { const int block = BlockFromStyle(subStyle); if (block >= 0) return classifiers[block].Base(); else return subStyle; } int DistanceToSecondaryStyles() const noexcept { return secondaryDistance; } int FirstAllocated() const noexcept { int start = 257; for (const WordClassifier &wc : classifiers) { if ((wc.Length() > 0) && (start > wc.Start())) start = wc.Start(); } return (start < 256) ? start : -1; } int LastAllocated() const noexcept { int last = -1; for (const WordClassifier &wc : classifiers) { if ((wc.Length() > 0) && (last < wc.Last())) last = wc.Last(); } return last; } void SetIdentifiers(int style, const char *identifiers, bool lowerCase=false) { const int block = BlockFromStyle(style); if (block >= 0) classifiers[block].SetIdentifiers(style, identifiers, lowerCase); } void Free() noexcept { allocated = 0; for (WordClassifier &wc : classifiers) { wc.Clear(); } } const WordClassifier &Classifier(int baseStyle) const noexcept { const int block = BlockFromBaseStyle(baseStyle); return classifiers[block >= 0 ? block : 0]; } }; } #endif tmpok_q575y/lexilla/lexlib/CharacterSet.h0000664000175000017500000001225614773064066020211 0ustar gusnangusnan// Scintilla source code edit control /** @file CharacterSet.h ** Encapsulates a set of characters. Used to test if a character is within a set. **/ // Copyright 2007 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef CHARACTERSET_H #define CHARACTERSET_H namespace Lexilla { template class CharacterSetArray { unsigned char bset[(N-1)/8 + 1] = {}; bool valueAfter = false; public: enum setBase { setNone=0, setLower=1, setUpper=2, setDigits=4, setAlpha=setLower|setUpper, setAlphaNum=setAlpha|setDigits }; CharacterSetArray(setBase base=setNone, const char *initialSet="", bool valueAfter_=false) noexcept { valueAfter = valueAfter_; AddString(initialSet); if (base & setLower) AddString("abcdefghijklmnopqrstuvwxyz"); if (base & setUpper) AddString("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); if (base & setDigits) AddString("0123456789"); } CharacterSetArray(const char *initialSet, bool valueAfter_=false) noexcept : CharacterSetArray(setNone, initialSet, valueAfter_) { } // For compatibility with previous version but should not be used in new code. CharacterSetArray(setBase base, const char *initialSet, [[maybe_unused]]int size_, bool valueAfter_=false) noexcept : CharacterSetArray(base, initialSet, valueAfter_) { assert(size_ == N); } void Add(int val) noexcept { assert(val >= 0); assert(val < N); bset[val >> 3] |= 1 << (val & 7); } void AddString(const char *setToAdd) noexcept { for (const char *cp=setToAdd; *cp; cp++) { const unsigned char uch = *cp; assert(uch < N); Add(uch); } } bool Contains(int val) const noexcept { assert(val >= 0); if (val < 0) return false; if (val >= N) return valueAfter; return bset[val >> 3] & (1 << (val & 7)); } bool Contains(char ch) const noexcept { // Overload char as char may be signed const unsigned char uch = ch; return Contains(uch); } }; using CharacterSet = CharacterSetArray<0x80>; // Functions for classifying characters template constexpr bool AnyOf(T t, Args... args) noexcept { #if defined(__clang__) static_assert(__is_integral(T) || __is_enum(T)); #endif return ((t == args) || ...); } // prevent pointer without template constexpr void AnyOf([[maybe_unused]] T *t, [[maybe_unused]] Args... args) noexcept {} template constexpr void AnyOf([[maybe_unused]] const T *t, [[maybe_unused]] Args... args) noexcept {} constexpr bool IsASpace(int ch) noexcept { return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d)); } constexpr bool IsASpaceOrTab(int ch) noexcept { return (ch == ' ') || (ch == '\t'); } constexpr bool IsADigit(int ch) noexcept { return (ch >= '0') && (ch <= '9'); } constexpr bool IsAHeXDigit(int ch) noexcept { return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f'); } constexpr bool IsAnOctalDigit(int ch) noexcept { return ch >= '0' && ch <= '7'; } constexpr bool IsADigit(int ch, int base) noexcept { if (base <= 10) { return (ch >= '0') && (ch < '0' + base); } else { return ((ch >= '0') && (ch <= '9')) || ((ch >= 'A') && (ch < 'A' + base - 10)) || ((ch >= 'a') && (ch < 'a' + base - 10)); } } constexpr bool IsASCII(int ch) noexcept { return (ch >= 0) && (ch < 0x80); } constexpr bool IsLowerCase(int ch) noexcept { return (ch >= 'a') && (ch <= 'z'); } constexpr bool IsUpperCase(int ch) noexcept { return (ch >= 'A') && (ch <= 'Z'); } constexpr bool IsUpperOrLowerCase(int ch) noexcept { return IsUpperCase(ch) || IsLowerCase(ch); } constexpr bool IsAlphaNumeric(int ch) noexcept { return ((ch >= '0') && (ch <= '9')) || ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')); } /** * Check if a character is a space. * This is ASCII specific but is safe with chars >= 0x80. */ constexpr bool isspacechar(int ch) noexcept { return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d)); } constexpr bool iswordchar(int ch) noexcept { return IsAlphaNumeric(ch) || ch == '.' || ch == '_'; } constexpr bool iswordstart(int ch) noexcept { return IsAlphaNumeric(ch) || ch == '_'; } constexpr bool isoperator(int ch) noexcept { if (IsAlphaNumeric(ch)) return false; if (ch == '%' || ch == '^' || ch == '&' || ch == '*' || ch == '(' || ch == ')' || ch == '-' || ch == '+' || ch == '=' || ch == '|' || ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ':' || ch == ';' || ch == '<' || ch == '>' || ch == ',' || ch == '/' || ch == '?' || ch == '!' || ch == '.' || ch == '~') return true; return false; } // Simple case functions for ASCII supersets. template constexpr T MakeUpperCase(T ch) noexcept { if (ch < 'a' || ch > 'z') return ch; else return ch - 'a' + 'A'; } template constexpr T MakeLowerCase(T ch) noexcept { if (ch < 'A' || ch > 'Z') return ch; else return ch - 'A' + 'a'; } int CompareCaseInsensitive(const char *a, const char *b) noexcept; bool EqualCaseInsensitive(std::string_view a, std::string_view b) noexcept; int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept; } #endif tmpok_q575y/lexilla/lexlib/PropSetSimple.h0000664000175000017500000000152314773064066020402 0ustar gusnangusnan// Scintilla source code edit control /** @file PropSetSimple.h ** A basic string to string map. **/ // Copyright 1998-2009 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef PROPSETSIMPLE_H #define PROPSETSIMPLE_H namespace Lexilla { class PropSetSimple { void *impl; public: PropSetSimple(); // Deleted so PropSetSimple objects can not be copied. PropSetSimple(const PropSetSimple&) = delete; PropSetSimple(PropSetSimple&&) = delete; PropSetSimple &operator=(const PropSetSimple&) = delete; PropSetSimple &operator=(PropSetSimple&&) = delete; virtual ~PropSetSimple(); bool Set(std::string_view key, std::string_view val); const char *Get(std::string_view key) const; int GetInt(std::string_view key, int defaultValue=0) const; }; } #endif tmpok_q575y/lexilla/lexlib/Accessor.cxx0000664000175000017500000000427114773064066017754 0ustar gusnangusnan// Scintilla source code edit control /** @file Accessor.cxx ** Interfaces between Scintilla and lexers. **/ // Copyright 1998-2002 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" #include "PropSetSimple.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" using namespace Lexilla; Accessor::Accessor(Scintilla::IDocument *pAccess_, PropSetSimple *pprops_) : LexAccessor(pAccess_), pprops(pprops_) { } int Accessor::GetPropertyInt(std::string_view key, int defaultValue) const { return pprops->GetInt(key, defaultValue); } int Accessor::IndentAmount(Sci_Position line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) { const Sci_Position end = Length(); int spaceFlags = 0; // Determines the indentation level of the current line and also checks for consistent // indentation compared to the previous line. // Indentation is judged consistent when the indentation whitespace of each line lines // the same or the indentation of one line is a prefix of the other. Sci_Position pos = LineStart(line); char ch = (*this)[pos]; int indent = 0; bool inPrevPrefix = line > 0; Sci_Position posPrev = inPrevPrefix ? LineStart(line-1) : 0; while ((ch == ' ' || ch == '\t') && (pos < end)) { if (inPrevPrefix) { const char chPrev = (*this)[posPrev++]; if (chPrev == ' ' || chPrev == '\t') { if (chPrev != ch) spaceFlags |= wsInconsistent; } else { inPrevPrefix = false; } } if (ch == ' ') { spaceFlags |= wsSpace; indent++; } else { // Tab spaceFlags |= wsTab; if (spaceFlags & wsSpace) spaceFlags |= wsSpaceTab; indent = (indent / 8 + 1) * 8; } ch = (*this)[++pos]; } *flags = spaceFlags; indent += SC_FOLDLEVELBASE; // if completely empty line or the start of a comment... if ((LineStart(line) == Length()) || (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') || (pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos))) return indent | SC_FOLDLEVELWHITEFLAG; else return indent; } tmpok_q575y/lexilla/lexlib/StyleContext.h0000664000175000017500000001277214773064066020311 0ustar gusnangusnan// Scintilla source code edit control /** @file StyleContext.h ** Lexer infrastructure. **/ // Copyright 1998-2004 by Neil Hodgson // This file is in the public domain. #ifndef STYLECONTEXT_H #define STYLECONTEXT_H namespace Lexilla { // All languages handled so far can treat all characters >= 0x80 as one class // which just continues the current token or starts an identifier if in default. // DBCS treated specially as the second character can be < 0x80 and hence // syntactically significant. UTF-8 avoids this as all trail bytes are >= 0x80 class StyleContext { LexAccessor &styler; Scintilla::IDocument * const multiByteAccess; const Sci_PositionU lengthDocument; const Sci_PositionU endPos; const Sci_Position lineDocEnd; // Used for optimizing GetRelativeCharacter Sci_PositionU posRelative = 0; Sci_PositionU currentPosLastRelative; Sci_Position offsetRelative = 0; void GetNextChar() { if (multiByteAccess) { chNext = multiByteAccess->GetCharacterAndWidth(currentPos+width, &widthNext); } else { const unsigned char charNext = styler.SafeGetCharAt(currentPos + width, 0); chNext = charNext; } // End of line determined from line end position, allowing CR, LF, // CRLF and Unicode line ends as set by document. const Sci_Position currentPosSigned = currentPos; if (currentLine < lineDocEnd) atLineEnd = currentPosSigned >= (lineStartNext-1); else // Last line atLineEnd = currentPosSigned >= lineStartNext; } public: Sci_PositionU currentPos; Sci_Position currentLine; Sci_Position lineEnd; Sci_Position lineStartNext; bool atLineStart; bool atLineEnd = false; int state; int chPrev = 0; int ch = 0; Sci_Position width = 0; int chNext = 0; Sci_Position widthNext = 1; StyleContext(Sci_PositionU startPos, Sci_PositionU length, int initStyle, LexAccessor &styler_, char chMask = '\377'); // Deleted so StyleContext objects can not be copied. StyleContext(const StyleContext &) = delete; StyleContext &operator=(const StyleContext &) = delete; void Complete() { styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state); styler.Flush(); } bool More() const noexcept { return currentPos < endPos; } void Forward() { if (currentPos < endPos) { atLineStart = atLineEnd; if (atLineStart) { currentLine++; lineEnd = styler.LineEnd(currentLine); lineStartNext = styler.LineStart(currentLine+1); } chPrev = ch; currentPos += width; ch = chNext; width = widthNext; GetNextChar(); } else { atLineStart = false; chPrev = ' '; ch = ' '; chNext = ' '; atLineEnd = true; } } void Forward(Sci_Position nb) { for (Sci_Position i = 0; i < nb; i++) { Forward(); } } void ForwardBytes(Sci_Position nb) { const Sci_PositionU forwardPos = currentPos + nb; while (forwardPos > currentPos) { const Sci_PositionU currentPosStart = currentPos; Forward(); if (currentPos == currentPosStart) { // Reached end return; } } } void ChangeState(int state_) noexcept { state = state_; } void SetState(int state_) { styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state); state = state_; } void ForwardSetState(int state_) { Forward(); styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state); state = state_; } Sci_Position LengthCurrent() const noexcept { return currentPos - styler.GetStartSegment(); } char GetRelativeChar(Sci_Position n, char chDefault='\0') { return styler.SafeGetCharAt(currentPos + n, chDefault); } int GetRelative(Sci_Position n, char chDefault='\0') { const unsigned char chRelative = styler.SafeGetCharAt(currentPos + n, chDefault); return chRelative; } int GetRelativeCharacter(Sci_Position n) { if (n == 0) return ch; if (multiByteAccess) { if ((currentPosLastRelative != currentPos) || ((n > 0) && ((offsetRelative < 0) || (n < offsetRelative))) || ((n < 0) && ((offsetRelative > 0) || (n > offsetRelative)))) { posRelative = currentPos; offsetRelative = 0; } const Sci_Position diffRelative = n - offsetRelative; const Sci_Position posNew = multiByteAccess->GetRelativePosition(posRelative, diffRelative); const int chReturn = multiByteAccess->GetCharacterAndWidth(posNew, nullptr); posRelative = posNew; currentPosLastRelative = currentPos; offsetRelative = n; return chReturn; } else { // fast version for single byte encodings const unsigned char chRelative = styler.SafeGetCharAt(currentPos + n, 0); return chRelative; } } bool MatchLineEnd() const noexcept { const Sci_Position currentPosSigned = currentPos; return currentPosSigned == lineEnd; } bool Match(char ch0) const noexcept { const unsigned char uch0 = ch0; return ch == uch0; } bool Match(char ch0, char ch1) const noexcept { const unsigned char uch0 = ch0; const unsigned char uch1 = ch1; return (ch == uch0) && (chNext == uch1); } bool Match(const char *s) { const unsigned char su = *s; if (ch != su) return false; s++; if (!*s) return true; const unsigned char sNext = *s; if (chNext != sNext) return false; s++; for (int n=2; *s; n++) { if (*s != styler.SafeGetCharAt(currentPos+n, 0)) return false; s++; } return true; } // Non-inline bool MatchIgnoreCase(const char *s); void GetCurrent(char *s, Sci_PositionU len) const; void GetCurrentLowered(char *s, Sci_PositionU len) const; enum class Transform { none, lower }; void GetCurrentString(std::string &string, Transform transform) const; }; } #endif tmpok_q575y/lexilla/lexlib/WordList.cxx0000664000175000017500000001666614773064066017774 0ustar gusnangusnan// Scintilla source code edit control /** @file WordList.cxx ** Hold a list of words. **/ // Copyright 1998-2002 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #include #include #include "WordList.h" #include "CharacterSet.h" using namespace Lexilla; namespace { /** * Creates an array that points into each word in the string and puts \0 terminators * after each word. */ std::unique_ptr ArrayFromWordList(char *wordlist, size_t slen, size_t *len, bool onlyLineEnds = false) { assert(wordlist); size_t words = 0; // For rapid determination of whether a character is a separator, build // a look up table. bool wordSeparator[256] = {}; // Initialise all to false. wordSeparator[static_cast('\r')] = true; wordSeparator[static_cast('\n')] = true; if (!onlyLineEnds) { wordSeparator[static_cast(' ')] = true; wordSeparator[static_cast('\t')] = true; } unsigned char prev = '\n'; for (int j = 0; wordlist[j]; j++) { const unsigned char curr = wordlist[j]; if (!wordSeparator[curr] && wordSeparator[prev]) words++; prev = curr; } std::unique_ptr keywords = std::make_unique(words + 1); size_t wordsStore = 0; if (words) { unsigned char previous = '\0'; for (size_t k = 0; k < slen; k++) { if (!wordSeparator[static_cast(wordlist[k])]) { if (!previous) { keywords[wordsStore] = &wordlist[k]; wordsStore++; } } else { wordlist[k] = '\0'; } previous = wordlist[k]; } } assert(wordsStore < (words + 1)); keywords[wordsStore] = &wordlist[slen]; *len = wordsStore; return keywords; } bool cmpWords(const char *a, const char *b) noexcept { return strcmp(a, b) < 0; } } WordList::WordList(bool onlyLineEnds_) noexcept : words(nullptr), list(nullptr), len(0), onlyLineEnds(onlyLineEnds_) { // Prevent warnings by static analyzers about uninitialized starts. starts[0] = -1; } WordList::~WordList() { Clear(); } WordList::operator bool() const noexcept { return len != 0; } bool WordList::operator!=(const WordList &other) const noexcept { if (len != other.len) return true; for (size_t i=0; i(len); } void WordList::Clear() noexcept { delete []list; list = nullptr; delete []words; words = nullptr; len = 0; } bool WordList::Set(const char *s, bool lowerCase) { const size_t lenS = strlen(s) + 1; std::unique_ptr listTemp = std::make_unique(lenS); memcpy(listTemp.get(), s, lenS); if (lowerCase) { for (size_t i = 0; i < lenS; i++) { listTemp[i] = MakeLowerCase(listTemp[i]); } } size_t lenTemp = 0; std::unique_ptr wordsTemp = ArrayFromWordList(listTemp.get(), lenS - 1, &lenTemp, onlyLineEnds); std::sort(wordsTemp.get(), wordsTemp.get() + lenTemp, cmpWords); if (lenTemp == len) { bool changed = false; for (size_t i = 0; i < lenTemp; i++) { if (strcmp(words[i], wordsTemp[i]) != 0) { changed = true; break; } } if (!changed) { return false; } } Clear(); words = wordsTemp.release(); list = listTemp.release(); len = lenTemp; std::fill(starts, std::end(starts), -1); for (int l = static_cast(len - 1); l >= 0; l--) { unsigned char const indexChar = words[l][0]; starts[indexChar] = l; } return true; } /** Check whether a string is in the list. * List elements are either exact matches or prefixes. * Prefix elements start with '^' and match all strings that start with the rest of the element * so '^GTK_' matches 'GTK_X', 'GTK_MAJOR_VERSION', and 'GTK_'. */ bool WordList::InList(const char *s) const noexcept { if (!words) return false; const char first = s[0]; const unsigned char firstChar = first; int j = starts[firstChar]; if (j >= 0) { while (words[j][0] == first) { if (s[1] == words[j][1]) { const char *a = words[j] + 1; const char *b = s + 1; while (*a && *a == *b) { a++; b++; } if (!*a && !*b) return true; } j++; } } j = starts[static_cast('^')]; if (j >= 0) { while (words[j][0] == '^') { const char *a = words[j] + 1; const char *b = s; while (*a && *a == *b) { a++; b++; } if (!*a) return true; j++; } } return false; } /** convenience overload so can easily call with std::string. */ bool WordList::InList(const std::string &s) const noexcept { return InList(s.c_str()); } /** similar to InList, but word s can be a substring of keyword. * eg. the keyword define is defined as def~ine. This means the word must start * with def to be a keyword, but also defi, defin and define are valid. * The marker is ~ in this case. */ bool WordList::InListAbbreviated(const char *s, const char marker) const noexcept { if (!words) return false; const char first = s[0]; const unsigned char firstChar = first; int j = starts[firstChar]; if (j >= 0) { while (words[j][0] == first) { bool isSubword = false; int start = 1; if (words[j][1] == marker) { isSubword = true; start++; } if (s[1] == words[j][start]) { const char *a = words[j] + start; const char *b = s + 1; while (*a && *a == *b) { a++; if (*a == marker) { isSubword = true; a++; } b++; } if ((!*a || isSubword) && !*b) return true; } j++; } } j = starts[static_cast('^')]; if (j >= 0) { while (words[j][0] == '^') { const char *a = words[j] + 1; const char *b = s; while (*a && *a == *b) { a++; b++; } if (!*a) return true; j++; } } return false; } /** similar to InListAbbreviated, but word s can be an abridged version of a keyword. * eg. the keyword is defined as "after.~:". This means the word must have a prefix (begins with) of * "after." and suffix (ends with) of ":" to be a keyword, Hence "after.field:" , "after.form.item:" are valid. * Similarly "~.is.valid" keyword is suffix only... hence "field.is.valid" , "form.is.valid" are valid. * The marker is ~ in this case. * No multiple markers check is done and wont work. */ bool WordList::InListAbridged(const char *s, const char marker) const noexcept { if (!words) return false; const char first = s[0]; const unsigned char firstChar = first; int j = starts[firstChar]; if (j >= 0) { while (words[j][0] == first) { const char *a = words[j]; const char *b = s; while (*a && *a == *b) { a++; if (*a == marker) { a++; const size_t suffixLengthA = strlen(a); const size_t suffixLengthB = strlen(b); if (suffixLengthA >= suffixLengthB) break; b = b + suffixLengthB - suffixLengthA - 1; } b++; } if (!*a && !*b) return true; j++; } } j = starts[static_cast(marker)]; if (j >= 0) { while (words[j][0] == marker) { const char *a = words[j] + 1; const char *b = s; const size_t suffixLengthA = strlen(a); const size_t suffixLengthB = strlen(b); if (suffixLengthA > suffixLengthB) { j++; continue; } b = b + suffixLengthB - suffixLengthA; while (*a && *a == *b) { a++; b++; } if (!*a && !*b) return true; j++; } } return false; } const char *WordList::WordAt(int n) const noexcept { return words[n]; } tmpok_q575y/lexilla/lexlib/LexAccessor.h0000664000175000017500000001445614773064066020060 0ustar gusnangusnan// Scintilla source code edit control /** @file LexAccessor.h ** Interfaces between Scintilla and lexers. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXACCESSOR_H #define LEXACCESSOR_H namespace Lexilla { enum class EncodingType { eightBit, unicode, dbcs }; class LexAccessor { private: Scintilla::IDocument *pAccess; enum {extremePosition=0x7FFFFFFF}; /** @a bufferSize is a trade off between time taken to copy the characters * and retrieval overhead. * @a slopSize positions the buffer before the desired position * in case there is some backtracking. */ enum {bufferSize=4000, slopSize=bufferSize/8}; char buf[bufferSize+1]; Sci_Position startPos; Sci_Position endPos; int codePage; enum EncodingType encodingType; Sci_Position lenDoc; char styleBuf[bufferSize]; Sci_Position validLen; Sci_PositionU startSeg; Sci_Position startPosStyling; int documentVersion; void Fill(Sci_Position position) { startPos = position - slopSize; if (startPos + bufferSize > lenDoc) startPos = lenDoc - bufferSize; if (startPos < 0) startPos = 0; endPos = startPos + bufferSize; if (endPos > lenDoc) endPos = lenDoc; pAccess->GetCharRange(buf, startPos, endPos-startPos); buf[endPos-startPos] = '\0'; } public: explicit LexAccessor(Scintilla::IDocument *pAccess_) : pAccess(pAccess_), startPos(extremePosition), endPos(0), codePage(pAccess->CodePage()), encodingType(EncodingType::eightBit), lenDoc(pAccess->Length()), validLen(0), startSeg(0), startPosStyling(0), documentVersion(pAccess->Version()) { // Prevent warnings by static analyzers about uninitialized buf and styleBuf. buf[0] = 0; styleBuf[0] = 0; switch (codePage) { case 65001: encodingType = EncodingType::unicode; break; case 932: case 936: case 949: case 950: case 1361: encodingType = EncodingType::dbcs; break; default: break; } } char operator[](Sci_Position position) { if (position < startPos || position >= endPos) { Fill(position); } return buf[position - startPos]; } Scintilla::IDocument *MultiByteAccess() const noexcept { return pAccess; } /** Safe version of operator[], returning a defined value for invalid position. */ char SafeGetCharAt(Sci_Position position, char chDefault=' ') { if (position < startPos || position >= endPos) { Fill(position); if (position < startPos || position >= endPos) { // Position is outside range of document return chDefault; } } return buf[position - startPos]; } bool IsLeadByte(char ch) const { const unsigned char uch = ch; return (uch >= 0x80) && // non-ASCII (encodingType == EncodingType::dbcs) && // IsDBCSLeadByte only for DBCS pAccess->IsDBCSLeadByte(ch); } EncodingType Encoding() const noexcept { return encodingType; } bool Match(Sci_Position pos, const char *s) { assert(s); for (int i=0; *s; i++) { if (*s != SafeGetCharAt(pos+i)) return false; s++; } return true; } bool MatchIgnoreCase(Sci_Position pos, const char *s); // Get first len - 1 characters in range [startPos_, endPos_). void GetRange(Sci_PositionU startPos_, Sci_PositionU endPos_, char *s, Sci_PositionU len) const; void GetRangeLowered(Sci_PositionU startPos_, Sci_PositionU endPos_, char *s, Sci_PositionU len) const; // Get all characters in range [startPos_, endPos_). std::string GetRange(Sci_PositionU startPos_, Sci_PositionU endPos_) const; std::string GetRangeLowered(Sci_PositionU startPos_, Sci_PositionU endPos_) const; char StyleAt(Sci_Position position) const { return pAccess->StyleAt(position); } int StyleIndexAt(Sci_Position position) const { const unsigned char style = pAccess->StyleAt(position); return style; } // Return style value from buffer when in buffer, else retrieve from document. // This is faster and can avoid calls to Flush() as that may be expensive. int BufferStyleAt(Sci_Position position) const { const Sci_Position index = position - startPosStyling; if (index >= 0 && index < validLen) { const unsigned char style = styleBuf[index]; return style; } const unsigned char style = pAccess->StyleAt(position); return style; } Sci_Position GetLine(Sci_Position position) const { return pAccess->LineFromPosition(position); } Sci_Position LineStart(Sci_Position line) const { return pAccess->LineStart(line); } Sci_Position LineEnd(Sci_Position line) const { return pAccess->LineEnd(line); } int LevelAt(Sci_Position line) const { return pAccess->GetLevel(line); } Sci_Position Length() const noexcept { return lenDoc; } void Flush() { if (validLen > 0) { pAccess->SetStyles(validLen, styleBuf); startPosStyling += validLen; validLen = 0; } } int GetLineState(Sci_Position line) const { return pAccess->GetLineState(line); } int SetLineState(Sci_Position line, int state) { return pAccess->SetLineState(line, state); } // Style setting void StartAt(Sci_PositionU start) { pAccess->StartStyling(start); startPosStyling = start; } Sci_PositionU GetStartSegment() const noexcept { return startSeg; } void StartSegment(Sci_PositionU pos) noexcept { startSeg = pos; } void ColourTo(Sci_PositionU pos, int chAttr) { // Only perform styling if non empty range if (pos != startSeg - 1) { assert(pos >= startSeg); if (pos < startSeg) { return; } if (validLen + (pos - startSeg + 1) >= bufferSize) Flush(); const unsigned char attr = chAttr & 0xffU; if (validLen + (pos - startSeg + 1) >= bufferSize) { // Too big for buffer so send directly pAccess->SetStyleFor(pos - startSeg + 1, attr); } else { for (Sci_PositionU i = startSeg; i <= pos; i++) { assert((startPosStyling + validLen) < Length()); styleBuf[validLen++] = attr; } } } startSeg = pos+1; } void SetLevel(Sci_Position line, int level) { pAccess->SetLevel(line, level); } void IndicatorFill(Sci_Position start, Sci_Position end, int indicator, int value) { pAccess->DecorationSetCurrentIndicator(indicator); pAccess->DecorationFillRange(start, value, end - start); } void ChangeLexerState(Sci_Position start, Sci_Position end) { pAccess->ChangeLexerState(start, end); } }; struct LexicalClass { int value; const char *name; const char *tags; const char *description; }; } #endif tmpok_q575y/lexilla/lexlib/CharacterCategory.cxx0000664000175000017500000011764714773064066021620 0ustar gusnangusnan// Scintilla source code edit control /** @file CharacterCategory.cxx ** Returns the Unicode general category of a character. ** Table automatically regenerated by scripts/GenerateCharacterCategory.py ** Should only be rarely regenerated for new versions of Unicode. **/ // Copyright 2013 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include "CharacterCategory.h" namespace Lexilla { namespace { // Use an unnamed namespace to protect the declarations from name conflicts const int catRanges[] = { //++Autogenerated -- start of section automatically generated // Created with Python 3.13.0, Unicode 15.1.0 25, 1046, 1073, 1171, 1201, 1293, 1326, 1361, 1394, 1425, 1452, 1489, 1544, 1873, 1938, 2033, 2080, 2925, 2961, 2990, 3028, 3051, 3092, 3105, 3949, 3986, 4014, 4050, 4089, 5142, 5169, 5203, 5333, 5361, 5396, 5429, 5444, 5487, 5522, 5562, 5589, 5620, 5653, 5682, 5706, 5780, 5793, 5841, 5908, 5930, 5956, 6000, 6026, 6129, 6144, 6898, 6912, 7137, 7922, 7937, 8192, 8225, 8256, 8289, 8320, 8353, 8384, 8417, 8448, 8481, 8512, 8545, 8576, 8609, 8640, 8673, 8704, 8737, 8768, 8801, 8832, 8865, 8896, 8929, 8960, 8993, 9024, 9057, 9088, 9121, 9152, 9185, 9216, 9249, 9280, 9313, 9344, 9377, 9408, 9441, 9472, 9505, 9536, 9569, 9600, 9633, 9664, 9697, 9728, 9761, 9792, 9825, 9856, 9889, 9920, 9953, 10016, 10049, 10080, 10113, 10144, 10177, 10208, 10241, 10272, 10305, 10336, 10369, 10400, 10433, 10464, 10497, 10560, 10593, 10624, 10657, 10688, 10721, 10752, 10785, 10816, 10849, 10880, 10913, 10944, 10977, 11008, 11041, 11072, 11105, 11136, 11169, 11200, 11233, 11264, 11297, 11328, 11361, 11392, 11425, 11456, 11489, 11520, 11553, 11584, 11617, 11648, 11681, 11712, 11745, 11776, 11809, 11840, 11873, 11904, 11937, 11968, 12001, 12032, 12097, 12128, 12161, 12192, 12225, 12320, 12385, 12416, 12449, 12480, 12545, 12576, 12673, 12736, 12865, 12896, 12961, 12992, 13089, 13184, 13249, 13280, 13345, 13376, 13409, 13440, 13473, 13504, 13569, 13600, 13633, 13696, 13729, 13760, 13825, 13856, 13953, 13984, 14017, 14048, 14113, 14180, 14208, 14241, 14340, 14464, 14498, 14529, 14560, 14594, 14625, 14656, 14690, 14721, 14752, 14785, 14816, 14849, 14880, 14913, 14944, 14977, 15008, 15041, 15072, 15105, 15136, 15169, 15200, 15233, 15296, 15329, 15360, 15393, 15424, 15457, 15488, 15521, 15552, 15585, 15616, 15649, 15680, 15713, 15744, 15777, 15808, 15841, 15904, 15938, 15969, 16000, 16033, 16064, 16161, 16192, 16225, 16256, 16289, 16320, 16353, 16384, 16417, 16448, 16481, 16512, 16545, 16576, 16609, 16640, 16673, 16704, 16737, 16768, 16801, 16832, 16865, 16896, 16929, 16960, 16993, 17024, 17057, 17088, 17121, 17152, 17185, 17216, 17249, 17280, 17313, 17344, 17377, 17408, 17441, 17472, 17505, 17536, 17569, 17600, 17633, 17664, 17697, 17728, 17761, 17792, 17825, 17856, 17889, 17920, 17953, 17984, 18017, 18240, 18305, 18336, 18401, 18464, 18497, 18528, 18657, 18688, 18721, 18752, 18785, 18816, 18849, 18880, 18913, 21124, 21153, 22019, 22612, 22723, 23124, 23555, 23732, 23939, 23988, 24003, 24052, 24581, 28160, 28193, 28224, 28257, 28291, 28340, 28352, 28385, 28445, 28483, 28513, 28625, 28640, 28701, 28820, 28864, 28913, 28928, 29053, 29056, 29117, 29120, 29185, 29216, 29789, 29792, 30081, 31200, 31233, 31296, 31393, 31488, 31521, 31552, 31585, 31616, 31649, 31680, 31713, 31744, 31777, 31808, 31841, 31872, 31905, 31936, 31969, 32000, 32033, 32064, 32097, 32128, 32161, 32192, 32225, 32384, 32417, 32466, 32480, 32513, 32544, 32609, 32672, 34305, 35840, 35873, 35904, 35937, 35968, 36001, 36032, 36065, 36096, 36129, 36160, 36193, 36224, 36257, 36288, 36321, 36352, 36385, 36416, 36449, 36480, 36513, 36544, 36577, 36608, 36641, 36672, 36705, 36736, 36769, 36800, 36833, 36864, 36897, 36949, 36965, 37127, 37184, 37217, 37248, 37281, 37312, 37345, 37376, 37409, 37440, 37473, 37504, 37537, 37568, 37601, 37632, 37665, 37696, 37729, 37760, 37793, 37824, 37857, 37888, 37921, 37952, 37985, 38016, 38049, 38080, 38113, 38144, 38177, 38208, 38241, 38272, 38305, 38336, 38369, 38400, 38433, 38464, 38497, 38528, 38561, 38592, 38625, 38656, 38689, 38720, 38753, 38784, 38817, 38848, 38881, 38912, 38977, 39008, 39041, 39072, 39105, 39136, 39169, 39200, 39233, 39264, 39297, 39328, 39361, 39424, 39457, 39488, 39521, 39552, 39585, 39616, 39649, 39680, 39713, 39744, 39777, 39808, 39841, 39872, 39905, 39936, 39969, 40000, 40033, 40064, 40097, 40128, 40161, 40192, 40225, 40256, 40289, 40320, 40353, 40384, 40417, 40448, 40481, 40512, 40545, 40576, 40609, 40640, 40673, 40704, 40737, 40768, 40801, 40832, 40865, 40896, 40929, 40960, 40993, 41024, 41057, 41088, 41121, 41152, 41185, 41216, 41249, 41280, 41313, 41344, 41377, 41408, 41441, 41472, 41505, 41536, 41569, 41600, 41633, 41664, 41697, 41728, 41761, 41792, 41825, 41856, 41889, 41920, 41953, 41984, 42017, 42048, 42081, 42112, 42145, 42176, 42209, 42240, 42273, 42304, 42337, 42368, 42401, 42432, 42465, 42525, 42528, 43773, 43811, 43857, 44033, 45361, 45388, 45437, 45493, 45555, 45597, 45605, 47052, 47077, 47121, 47141, 47217, 47237, 47313, 47333, 47389, 47620, 48509, 48612, 48753, 48829, 49178, 49362, 49457, 49523, 49553, 49621, 49669, 50033, 50074, 50097, 50180, 51203, 51236, 51557, 52232, 52561, 52676, 52741, 52772, 55953, 55972, 56005, 56250, 56277, 56293, 56483, 56549, 56629, 56645, 56772, 56840, 57156, 57269, 57316, 57361, 57821, 57850, 57860, 57893, 57924, 58885, 59773, 59812, 62661, 63012, 63069, 63496, 63812, 64869, 65155, 65237, 65265, 65347, 65405, 65445, 65491, 65540, 66245, 66371, 66405, 66691, 66725, 66819, 66853, 67037, 67089, 67581, 67588, 68389, 68509, 68561, 68605, 68612, 68989, 69124, 69908, 69924, 70141, 70170, 70237, 70405, 70660, 71971, 72005, 72794, 72805, 73830, 73860, 75589, 75622, 75653, 75684, 75718, 75813, 76070, 76197, 76230, 76292, 76325, 76548, 76869, 76945, 77000, 77329, 77347, 77380, 77861, 77894, 77981, 77988, 78269, 78308, 78397, 78436, 79165, 79172, 79421, 79428, 79485, 79556, 79709, 79749, 79780, 79814, 79909, 80061, 80102, 80189, 80230, 80293, 80324, 80381, 80614, 80669, 80772, 80861, 80868, 80965, 81053, 81096, 81412, 81491, 81546, 81749, 81779, 81796, 81841, 81861, 81917, 81957, 82022, 82077, 82084, 82301, 82404, 82493, 82532, 83261, 83268, 83517, 83524, 83613, 83620, 83709, 83716, 83805, 83845, 83901, 83910, 84005, 84093, 84197, 84285, 84325, 84445, 84517, 84573, 84772, 84925, 84932, 84989, 85192, 85509, 85572, 85669, 85713, 85757, 86053, 86118, 86173, 86180, 86493, 86500, 86621, 86628, 87357, 87364, 87613, 87620, 87709, 87716, 87901, 87941, 87972, 88006, 88101, 88285, 88293, 88358, 88413, 88422, 88485, 88541, 88580, 88637, 89092, 89157, 89245, 89288, 89617, 89651, 89693, 89892, 89925, 90141, 90149, 90182, 90269, 90276, 90557, 90596, 90685, 90724, 91453, 91460, 91709, 91716, 91805, 91812, 91997, 92037, 92068, 92102, 92133, 92166, 92197, 92349, 92390, 92477, 92518, 92581, 92637, 92837, 92902, 92957, 93060, 93149, 93156, 93253, 93341, 93384, 93717, 93732, 93770, 93981, 94277, 94308, 94365, 94372, 94589, 94660, 94781, 94788, 94941, 95012, 95101, 95108, 95165, 95172, 95261, 95332, 95421, 95492, 95613, 95684, 96093, 96198, 96261, 96294, 96381, 96454, 96573, 96582, 96677, 96733, 96772, 96829, 96998, 97053, 97480, 97802, 97909, 98099, 98133, 98173, 98309, 98342, 98437, 98468, 98749, 98756, 98877, 98884, 99645, 99652, 100189, 100229, 100260, 100293, 100390, 100541, 100549, 100669, 100677, 100829, 101029, 101117, 101124, 101245, 101284, 101341, 101380, 101445, 101533, 101576, 101917, 102129, 102154, 102389, 102404, 102437, 102470, 102545, 102564, 102845, 102852, 102973, 102980, 103741, 103748, 104093, 104100, 104285, 104325, 104356, 104390, 104421, 104454, 104637, 104645, 104678, 104765, 104774, 104837, 104925, 105126, 105213, 105380, 105469, 105476, 105541, 105629, 105672, 106013, 106020, 106086, 106141, 106501, 106566, 106628, 106941, 106948, 107069, 107076, 108389, 108452, 108486, 108581, 108733, 108742, 108861, 108870, 108965, 108996, 109045, 109085, 109188, 109286, 109322, 109540, 109637, 109725, 109768, 110090, 110389, 110404, 110621, 110629, 110662, 110749, 110756, 111357, 111428, 112221, 112228, 112541, 112548, 112605, 112644, 112893, 112965, 113021, 113126, 113221, 113341, 113349, 113405, 113414, 113693, 113864, 114205, 114246, 114321, 114365, 114724, 116261, 116292, 116357, 116605, 116723, 116740, 116931, 116965, 117233, 117256, 117585, 117661, 118820, 118909, 118916, 118973, 118980, 119165, 119172, 119965, 119972, 120029, 120036, 120357, 120388, 120453, 120740, 120797, 120836, 121021, 121027, 121085, 121093, 121341, 121352, 121693, 121732, 121885, 122884, 122933, 123025, 123509, 123537, 123573, 123653, 123733, 123912, 124234, 124565, 124581, 124629, 124645, 124693, 124709, 124749, 124782, 124813, 124846, 124870, 124932, 125213, 125220, 126397, 126501, 126950, 126981, 127153, 127173, 127236, 127397, 127773, 127781, 128957, 128981, 129221, 129269, 129469, 129493, 129553, 129717, 129841, 129917, 131076, 132454, 132517, 132646, 132677, 132870, 132901, 132966, 133029, 133092, 133128, 133457, 133636, 133830, 133893, 133956, 134085, 134180, 134214, 134308, 134374, 134596, 134693, 134820, 135237, 135270, 135333, 135398, 135589, 135620, 135654, 135688, 136006, 136101, 136149, 136192, 137437, 137440, 137501, 137632, 137693, 137729, 139121, 139139, 139169, 139268, 149821, 149828, 149981, 150020, 150269, 150276, 150333, 150340, 150493, 150532, 151869, 151876, 152029, 152068, 153149, 153156, 153309, 153348, 153597, 153604, 153661, 153668, 153821, 153860, 154365, 154372, 156221, 156228, 156381, 156420, 158589, 158629, 158737, 159018, 159677, 159748, 160277, 160605, 160768, 163549, 163585, 163805, 163852, 163876, 183733, 183761, 183780, 184342, 184356, 185197, 185230, 185277, 185348, 187761, 187849, 187940, 188221, 188420, 188997, 189094, 189149, 189412, 190021, 190086, 190129, 190205, 190468, 191045, 191133, 191492, 191933, 191940, 192061, 192069, 192157, 192516, 194181, 194246, 194277, 194502, 194757, 194790, 194853, 195217, 195299, 195345, 195443, 195460, 195493, 195549, 195592, 195933, 196106, 196445, 196625, 196812, 196849, 196965, 197082, 197093, 197128, 197469, 197636, 198755, 198788, 200509, 200708, 200869, 200932, 202021, 202052, 202109, 202244, 204509, 204804, 205821, 205829, 205926, 206053, 206118, 206237, 206342, 206405, 206438, 206629, 206749, 206869, 206909, 206993, 207048, 207364, 208349, 208388, 208573, 208900, 210333, 210436, 211293, 211464, 211786, 211837, 211925, 212996, 213733, 213798, 213861, 213917, 213969, 214020, 215718, 215749, 215782, 215813, 216061, 216069, 216102, 216133, 216166, 216229, 216486, 216677, 217021, 217061, 217096, 217437, 217608, 217949, 218129, 218339, 218385, 218589, 218629, 219079, 219109, 219645, 221189, 221318, 221348, 222853, 222886, 222917, 223078, 223109, 223142, 223301, 223334, 223396, 223677, 223752, 224081, 224309, 224613, 224917, 225201, 225277, 225285, 225350, 225380, 226342, 226373, 226502, 226565, 226630, 226661, 226756, 226824, 227140, 228549, 228582, 228613, 228678, 228773, 228806, 228837, 228934, 229021, 229265, 229380, 230534, 230789, 231046, 231109, 231197, 231281, 231432, 231773, 231844, 231944, 232260, 233219, 233425, 233473, 233789, 233984, 235389, 235424, 235537, 235805, 236037, 236145, 236165, 236582, 236613, 236836, 236965, 236996, 237189, 237220, 237286, 237317, 237380, 237437, 237569, 238979, 240993, 241411, 241441, 242531, 243717, 245760, 245793, 245824, 245857, 245888, 245921, 245952, 245985, 246016, 246049, 246080, 246113, 246144, 246177, 246208, 246241, 246272, 246305, 246336, 246369, 246400, 246433, 246464, 246497, 246528, 246561, 246592, 246625, 246656, 246689, 246720, 246753, 246784, 246817, 246848, 246881, 246912, 246945, 246976, 247009, 247040, 247073, 247104, 247137, 247168, 247201, 247232, 247265, 247296, 247329, 247360, 247393, 247424, 247457, 247488, 247521, 247552, 247585, 247616, 247649, 247680, 247713, 247744, 247777, 247808, 247841, 247872, 247905, 247936, 247969, 248000, 248033, 248064, 248097, 248128, 248161, 248192, 248225, 248256, 248289, 248320, 248353, 248384, 248417, 248448, 248481, 248512, 248545, 248576, 248609, 248640, 248673, 248704, 248737, 248768, 248801, 248832, 248865, 248896, 248929, 248960, 248993, 249024, 249057, 249088, 249121, 249152, 249185, 249216, 249249, 249280, 249313, 249344, 249377, 249408, 249441, 249472, 249505, 249536, 249569, 249600, 249633, 249664, 249697, 249728, 249761, 249792, 249825, 249856, 249889, 249920, 249953, 249984, 250017, 250048, 250081, 250112, 250145, 250176, 250209, 250240, 250273, 250304, 250337, 250368, 250401, 250432, 250465, 250496, 250529, 250816, 250849, 250880, 250913, 250944, 250977, 251008, 251041, 251072, 251105, 251136, 251169, 251200, 251233, 251264, 251297, 251328, 251361, 251392, 251425, 251456, 251489, 251520, 251553, 251584, 251617, 251648, 251681, 251712, 251745, 251776, 251809, 251840, 251873, 251904, 251937, 251968, 252001, 252032, 252065, 252096, 252129, 252160, 252193, 252224, 252257, 252288, 252321, 252352, 252385, 252416, 252449, 252480, 252513, 252544, 252577, 252608, 252641, 252672, 252705, 252736, 252769, 252800, 252833, 252864, 252897, 252928, 252961, 252992, 253025, 253056, 253089, 253120, 253153, 253184, 253217, 253248, 253281, 253312, 253345, 253376, 253409, 253440, 253473, 253504, 253537, 253568, 253601, 253632, 253665, 253696, 253729, 253760, 253793, 253824, 253857, 253888, 253921, 254208, 254465, 254685, 254720, 254941, 254977, 255232, 255489, 255744, 256001, 256221, 256256, 256477, 256513, 256797, 256800, 256861, 256864, 256925, 256928, 256989, 256992, 257025, 257280, 257537, 258013, 258049, 258306, 258561, 258818, 259073, 259330, 259585, 259773, 259777, 259840, 259970, 260020, 260033, 260084, 260161, 260285, 260289, 260352, 260482, 260532, 260609, 260765, 260801, 260864, 261021, 261044, 261121, 261376, 261556, 261661, 261697, 261821, 261825, 261888, 262018, 262068, 262141, 262166, 262522, 262668, 262865, 262927, 262960, 262989, 263023, 263088, 263117, 263151, 263185, 263447, 263480, 263514, 263670, 263697, 263983, 264016, 264049, 264171, 264241, 264338, 264365, 264398, 264433, 264786, 264817, 264843, 264881, 265206, 265242, 265405, 265434, 265738, 265763, 265821, 265866, 266066, 266157, 266190, 266211, 266250, 266578, 266669, 266702, 266749, 266755, 267197, 267283, 268349, 268805, 269223, 269349, 269383, 269477, 269885, 270357, 270400, 270453, 270560, 270613, 270657, 270688, 270785, 270848, 270945, 270997, 271008, 271061, 271122, 271136, 271317, 271488, 271541, 271552, 271605, 271616, 271669, 271680, 271829, 271841, 271872, 272001, 272036, 272161, 272213, 272257, 272320, 272402, 272544, 272577, 272725, 272754, 272789, 272833, 272885, 272906, 273417, 274528, 274561, 274601, 274730, 274773, 274845, 274962, 275125, 275282, 275349, 275474, 275509, 275570, 275605, 275666, 275701, 275922, 275957, 276946, 277013, 277074, 277109, 277138, 277173, 278162, 286741, 286989, 287022, 287053, 287086, 287125, 287762, 287829, 288045, 288078, 288117, 290706, 290741, 291698, 292501, 293778, 293973, 296189, 296981, 297341, 297994, 299925, 302410, 303125, 308978, 309013, 309298, 309333, 311058, 311317, 314866, 314901, 322829, 322862, 322893, 322926, 322957, 322990, 323021, 323054, 323085, 323118, 323149, 323182, 323213, 323246, 323274, 324245, 325650, 325805, 325838, 325874, 326861, 326894, 326925, 326958, 326989, 327022, 327053, 327086, 327117, 327150, 327186, 327701, 335890, 340077, 340110, 340141, 340174, 340205, 340238, 340269, 340302, 340333, 340366, 340397, 340430, 340461, 340494, 340525, 340558, 340589, 340622, 340653, 340686, 340717, 340750, 340786, 342797, 342830, 342861, 342894, 342930, 343949, 343982, 344018, 352277, 353810, 354485, 354546, 354741, 355997, 356053, 357085, 357109, 360448, 361985, 363520, 363553, 363584, 363681, 363744, 363777, 363808, 363841, 363872, 363905, 363936, 364065, 364096, 364129, 364192, 364225, 364419, 364480, 364577, 364608, 364641, 364672, 364705, 364736, 364769, 364800, 364833, 364864, 364897, 364928, 364961, 364992, 365025, 365056, 365089, 365120, 365153, 365184, 365217, 365248, 365281, 365312, 365345, 365376, 365409, 365440, 365473, 365504, 365537, 365568, 365601, 365632, 365665, 365696, 365729, 365760, 365793, 365824, 365857, 365888, 365921, 365952, 365985, 366016, 366049, 366080, 366113, 366144, 366177, 366208, 366241, 366272, 366305, 366336, 366369, 366400, 366433, 366464, 366497, 366528, 366561, 366592, 366625, 366656, 366689, 366720, 366753, 366784, 366817, 366848, 366881, 366912, 366945, 366976, 367009, 367040, 367073, 367104, 367137, 367168, 367201, 367232, 367265, 367296, 367329, 367360, 367393, 367424, 367457, 367488, 367521, 367552, 367585, 367616, 367649, 367680, 367713, 367797, 367968, 368001, 368032, 368065, 368101, 368192, 368225, 368285, 368433, 368554, 368593, 368641, 369885, 369889, 369949, 370081, 370141, 370180, 371997, 372195, 372241, 372285, 372709, 372740, 373501, 373764, 374013, 374020, 374269, 374276, 374525, 374532, 374781, 374788, 375037, 375044, 375293, 375300, 375549, 375556, 375805, 375813, 376849, 376911, 376944, 376975, 377008, 377041, 377135, 377168, 377201, 377231, 377264, 377297, 377580, 377617, 377676, 377713, 377743, 377776, 377809, 377871, 377904, 377933, 377966, 377997, 378030, 378061, 378094, 378125, 378158, 378193, 378339, 378385, 378700, 378769, 378892, 378929, 378957, 378993, 379413, 379473, 379565, 379598, 379629, 379662, 379693, 379726, 379757, 379790, 379820, 379869, 380949, 381789, 381813, 384669, 385045, 391901, 392725, 393238, 393265, 393365, 393379, 393412, 393449, 393485, 393518, 393549, 393582, 393613, 393646, 393677, 393710, 393741, 393774, 393813, 393869, 393902, 393933, 393966, 393997, 394030, 394061, 394094, 394124, 394157, 394190, 394261, 394281, 394565, 394694, 394764, 394787, 394965, 395017, 395107, 395140, 395185, 395221, 395293, 395300, 398077, 398117, 398196, 398243, 398308, 398348, 398372, 401265, 401283, 401380, 401437, 401572, 402973, 402980, 406013, 406037, 406090, 406229, 406532, 407573, 408733, 409077, 409092, 409621, 410621, 410634, 410965, 411914, 412181, 412202, 412693, 413706, 414037, 415274, 415765, 425988, 636949, 638980, 1311395, 1311428, 1348029, 1348117, 1349885, 1350148, 1351427, 1351633, 1351684, 1360259, 1360305, 1360388, 1360904, 1361220, 1361309, 1361920, 1361953, 1361984, 1362017, 1362048, 1362081, 1362112, 1362145, 1362176, 1362209, 1362240, 1362273, 1362304, 1362337, 1362368, 1362401, 1362432, 1362465, 1362496, 1362529, 1362560, 1362593, 1362624, 1362657, 1362688, 1362721, 1362752, 1362785, 1362816, 1362849, 1362880, 1362913, 1362944, 1362977, 1363008, 1363041, 1363072, 1363105, 1363136, 1363169, 1363200, 1363233, 1363264, 1363297, 1363328, 1363361, 1363396, 1363429, 1363463, 1363569, 1363589, 1363921, 1363939, 1363968, 1364001, 1364032, 1364065, 1364096, 1364129, 1364160, 1364193, 1364224, 1364257, 1364288, 1364321, 1364352, 1364385, 1364416, 1364449, 1364480, 1364513, 1364544, 1364577, 1364608, 1364641, 1364672, 1364705, 1364736, 1364769, 1364800, 1364833, 1364867, 1364933, 1364996, 1367241, 1367557, 1367633, 1367837, 1368084, 1368803, 1369108, 1369152, 1369185, 1369216, 1369249, 1369280, 1369313, 1369344, 1369377, 1369408, 1369441, 1369472, 1369505, 1369536, 1369569, 1369664, 1369697, 1369728, 1369761, 1369792, 1369825, 1369856, 1369889, 1369920, 1369953, 1369984, 1370017, 1370048, 1370081, 1370112, 1370145, 1370176, 1370209, 1370240, 1370273, 1370304, 1370337, 1370368, 1370401, 1370432, 1370465, 1370496, 1370529, 1370560, 1370593, 1370624, 1370657, 1370688, 1370721, 1370752, 1370785, 1370816, 1370849, 1370880, 1370913, 1370944, 1370977, 1371008, 1371041, 1371072, 1371105, 1371136, 1371169, 1371200, 1371233, 1371264, 1371297, 1371328, 1371361, 1371392, 1371425, 1371456, 1371489, 1371520, 1371553, 1371584, 1371617, 1371651, 1371681, 1371936, 1371969, 1372000, 1372033, 1372064, 1372129, 1372160, 1372193, 1372224, 1372257, 1372288, 1372321, 1372352, 1372385, 1372419, 1372468, 1372512, 1372545, 1372576, 1372609, 1372644, 1372672, 1372705, 1372736, 1372769, 1372864, 1372897, 1372928, 1372961, 1372992, 1373025, 1373056, 1373089, 1373120, 1373153, 1373184, 1373217, 1373248, 1373281, 1373312, 1373345, 1373376, 1373409, 1373440, 1373473, 1373504, 1373665, 1373696, 1373857, 1373888, 1373921, 1373952, 1373985, 1374016, 1374049, 1374080, 1374113, 1374144, 1374177, 1374208, 1374241, 1374272, 1374305, 1374336, 1374465, 1374496, 1374529, 1374589, 1374720, 1374753, 1374813, 1374817, 1374877, 1374881, 1374912, 1374945, 1374976, 1375009, 1375069, 1375811, 1375904, 1375937, 1375972, 1376003, 1376065, 1376100, 1376325, 1376356, 1376453, 1376484, 1376613, 1376644, 1377382, 1377445, 1377510, 1377557, 1377669, 1377725, 1377802, 1378005, 1378067, 1378101, 1378141, 1378308, 1379985, 1380125, 1380358, 1380420, 1382022, 1382533, 1382621, 1382865, 1382920, 1383261, 1383429, 1384004, 1384209, 1384292, 1384337, 1384356, 1384421, 1384456, 1384772, 1385669, 1385937, 1385988, 1386725, 1387078, 1387165, 1387505, 1387524, 1388477, 1388549, 1388646, 1388676, 1390181, 1390214, 1390277, 1390406, 1390469, 1390534, 1390641, 1391069, 1391075, 1391112, 1391453, 1391569, 1391620, 1391781, 1391811, 1391844, 1392136, 1392452, 1392637, 1392644, 1393957, 1394150, 1394213, 1394278, 1394341, 1394429, 1394692, 1394789, 1394820, 1395077, 1395110, 1395165, 1395208, 1395549, 1395601, 1395716, 1396227, 1396260, 1396469, 1396548, 1396582, 1396613, 1396646, 1396676, 1398277, 1398308, 1398341, 1398436, 1398501, 1398564, 1398725, 1398788, 1398821, 1398852, 1398909, 1399652, 1399715, 1399761, 1399812, 1400166, 1400197, 1400262, 1400337, 1400388, 1400419, 1400486, 1400517, 1400573, 1400868, 1401085, 1401124, 1401341, 1401380, 1401597, 1401860, 1402109, 1402116, 1402365, 1402369, 1403764, 1403779, 1403905, 1404195, 1404244, 1404317, 1404417, 1406980, 1408102, 1408165, 1408198, 1408261, 1408294, 1408369, 1408390, 1408421, 1408477, 1408520, 1408861, 1409028, 1766557, 1766916, 1767677, 1767780, 1769373, 1769499, 1835036, 2039812, 2051549, 2051588, 2055005, 2056193, 2056445, 2056801, 2056989, 2057124, 2057157, 2057188, 2057522, 2057540, 2057981, 2057988, 2058173, 2058180, 2058237, 2058244, 2058333, 2058340, 2058429, 2058436, 2061908, 2062461, 2062948, 2074574, 2074605, 2074645, 2075140, 2077213, 2077252, 2079005, 2079221, 2079261, 2080260, 2080659, 2080693, 2080773, 2081297, 2081517, 2081550, 2081585, 2081629, 2081797, 2082321, 2082348, 2082411, 2082477, 2082510, 2082541, 2082574, 2082605, 2082638, 2082669, 2082702, 2082733, 2082766, 2082797, 2082830, 2082861, 2082894, 2082925, 2082958, 2082993, 2083053, 2083086, 2083121, 2083243, 2083345, 2083453, 2083473, 2083596, 2083629, 2083662, 2083693, 2083726, 2083757, 2083790, 2083825, 2083922, 2083948, 2083986, 2084093, 2084113, 2084147, 2084177, 2084253, 2084356, 2084541, 2084548, 2088893, 2088954, 2088989, 2089009, 2089107, 2089137, 2089229, 2089262, 2089297, 2089330, 2089361, 2089388, 2089425, 2089480, 2089809, 2089874, 2089969, 2090016, 2090861, 2090897, 2090926, 2090964, 2090987, 2091028, 2091041, 2091885, 2091922, 2091950, 2091986, 2092013, 2092046, 2092081, 2092109, 2092142, 2092177, 2092228, 2092547, 2092580, 2094019, 2094084, 2095101, 2095172, 2095389, 2095428, 2095645, 2095684, 2095901, 2095940, 2096061, 2096147, 2096210, 2096244, 2096277, 2096307, 2096381, 2096405, 2096434, 2096565, 2096637, 2096954, 2097045, 2097117, 2097156, 2097565, 2097572, 2098429, 2098436, 2099069, 2099076, 2099165, 2099172, 2099677, 2099716, 2100189, 2101252, 2105213, 2105361, 2105469, 2105578, 2107037, 2107125, 2107401, 2109098, 2109237, 2109770, 2109845, 2109949, 2109973, 2110397, 2110485, 2110525, 2112021, 2113445, 2113501, 2117636, 2118589, 2118660, 2120253, 2120709, 2120746, 2121629, 2121732, 2122762, 2122909, 2123172, 2123817, 2123844, 2124105, 2124157, 2124292, 2125509, 2125693, 2125828, 2126813, 2126833, 2126852, 2128029, 2128132, 2128401, 2128425, 2128605, 2129920, 2131201, 2132484, 2135005, 2135048, 2135389, 2135552, 2136733, 2136833, 2138013, 2138116, 2139421, 2139652, 2141341, 2141681, 2141696, 2142077, 2142080, 2142589, 2142592, 2142845, 2142848, 2142941, 2142945, 2143325, 2143329, 2143837, 2143841, 2144093, 2144097, 2144189, 2146308, 2156285, 2156548, 2157277, 2157572, 2157853, 2158595, 2158813, 2158819, 2160189, 2160195, 2160509, 2162692, 2162909, 2162948, 2163005, 2163012, 2164445, 2164452, 2164541, 2164612, 2164669, 2164708, 2165469, 2165489, 2165514, 2165764, 2166517, 2166570, 2166788, 2167805, 2168042, 2168349, 2169860, 2170493, 2170500, 2170589, 2170730, 2170884, 2171594, 2171805, 2171889, 2171908, 2172765, 2172913, 2172957, 2174980, 2176797, 2176906, 2176964, 2177034, 2177565, 2177610, 2179076, 2179109, 2179229, 2179237, 2179325, 2179461, 2179588, 2179741, 2179748, 2179869, 2179876, 2180829, 2180869, 2180989, 2181093, 2181130, 2181437, 2181649, 2181949, 2182148, 2183082, 2183153, 2183172, 2184106, 2184221, 2185220, 2185493, 2185508, 2186405, 2186493, 2186602, 2186769, 2187005, 2187268, 2189021, 2189105, 2189316, 2190045, 2190090, 2190340, 2190973, 2191114, 2191364, 2191965, 2192177, 2192317, 2192682, 2192925, 2195460, 2197821, 2199552, 2201213, 2201601, 2203261, 2203466, 2203652, 2204805, 2204957, 2205192, 2205533, 2214922, 2215933, 2215940, 2217309, 2217317, 2217388, 2217437, 2217476, 2217565, 2219941, 2220036, 2220970, 2221284, 2221341, 2221572, 2222277, 2222634, 2222769, 2222941, 2223620, 2224197, 2224337, 2224477, 2225668, 2226346, 2226589, 2227204, 2227965, 2228230, 2228261, 2228294, 2228324, 2230021, 2230513, 2230749, 2230858, 2231496, 2231813, 2231844, 2231909, 2231972, 2232029, 2232293, 2232390, 2232420, 2233862, 2233957, 2234086, 2234149, 2234225, 2234298, 2234321, 2234437, 2234493, 2234810, 2234845, 2234884, 2235709, 2235912, 2236253, 2236421, 2236516, 2237669, 2237830, 2237861, 2238141, 2238152, 2238481, 2238596, 2238630, 2238692, 2238749, 2238980, 2240101, 2240145, 2240196, 2240253, 2240517, 2240582, 2240612, 2242150, 2242245, 2242534, 2242596, 2242737, 2242853, 2242993, 2243014, 2243045, 2243080, 2243396, 2243441, 2243460, 2243505, 2243613, 2243626, 2244285, 2244612, 2245213, 2245220, 2246022, 2246117, 2246214, 2246277, 2246310, 2246341, 2246417, 2246597, 2246628, 2246693, 2246749, 2248708, 2248957, 2248964, 2249021, 2249028, 2249181, 2249188, 2249693, 2249700, 2250033, 2250077, 2250244, 2251749, 2251782, 2251877, 2252157, 2252296, 2252637, 2252805, 2252870, 2252957, 2252964, 2253245, 2253284, 2253373, 2253412, 2254141, 2254148, 2254397, 2254404, 2254493, 2254500, 2254685, 2254693, 2254756, 2254790, 2254853, 2254886, 2255037, 2255078, 2255165, 2255206, 2255325, 2255364, 2255421, 2255590, 2255645, 2255780, 2255942, 2256029, 2256069, 2256317, 2256389, 2256573, 2260996, 2262694, 2262789, 2263046, 2263109, 2263206, 2263237, 2263268, 2263409, 2263560, 2263889, 2263965, 2263985, 2264005, 2264036, 2264157, 2265092, 2266630, 2266725, 2266918, 2266949, 2266982, 2267109, 2267174, 2267205, 2267268, 2267345, 2267364, 2267421, 2267656, 2267997, 2273284, 2274790, 2274885, 2275037, 2275078, 2275205, 2275270, 2275301, 2275377, 2276100, 2276229, 2276317, 2277380, 2278918, 2279013, 2279270, 2279333, 2279366, 2279397, 2279473, 2279556, 2279613, 2279944, 2280285, 2280465, 2280893, 2281476, 2282853, 2282886, 2282917, 2282950, 2283013, 2283206, 2283237, 2283268, 2283313, 2283357, 2283528, 2283869, 2285572, 2286461, 2286501, 2286598, 2286661, 2286790, 2286821, 2287005, 2287112, 2287434, 2287505, 2287605, 2287620, 2287869, 2293764, 2295174, 2295269, 2295558, 2295589, 2295665, 2295709, 2298880, 2299905, 2300936, 2301258, 2301565, 2301924, 2302205, 2302244, 2302301, 2302340, 2302621, 2302628, 2302717, 2302724, 2303494, 2303709, 2303718, 2303805, 2303845, 2303910, 2303941, 2303972, 2304006, 2304036, 2304070, 2304101, 2304145, 2304253, 2304520, 2304861, 2307076, 2307357, 2307396, 2308646, 2308741, 2308893, 2308933, 2308998, 2309125, 2309156, 2309201, 2309220, 2309254, 2309309, 2310148, 2310181, 2310500, 2311781, 2311974, 2312004, 2312037, 2312177, 2312421, 2312477, 2312708, 2312741, 2312934, 2312997, 2313092, 2314565, 2314982, 2315013, 2315089, 2315172, 2315217, 2315389, 2315780, 2318141, 2318353, 2318685, 2326532, 2326845, 2326852, 2328038, 2328069, 2328317, 2328325, 2328518, 2328549, 2328580, 2328625, 2328797, 2329096, 2329418, 2330045, 2330129, 2330180, 2331165, 2331205, 2331933, 2331942, 2331973, 2332198, 2332229, 2332294, 2332325, 2332413, 2334724, 2334973, 2334980, 2335069, 2335076, 2336293, 2336509, 2336581, 2336637, 2336645, 2336733, 2336741, 2336964, 2336997, 2337053, 2337288, 2337629, 2337796, 2338013, 2338020, 2338109, 2338116, 2339142, 2339325, 2339333, 2339421, 2339430, 2339493, 2339526, 2339557, 2339588, 2339645, 2339848, 2340189, 2350084, 2350693, 2350758, 2350833, 2350909, 2351109, 2351172, 2351206, 2351236, 2351677, 2351684, 2352774, 2352837, 2353021, 2353094, 2353157, 2353190, 2353221, 2353265, 2353672, 2354013, 2356740, 2356797, 2357258, 2357941, 2358195, 2358325, 2358877, 2359281, 2359300, 2388829, 2392073, 2395645, 2395665, 2395837, 2396164, 2402461, 2486788, 2489905, 2489981, 2490372, 2524698, 2525189, 2525220, 2525413, 2525917, 2654212, 2672893, 2949124, 2967357, 2967556, 2968573, 2968584, 2968925, 2969041, 2969092, 2971645, 2971656, 2971997, 2972164, 2973149, 2973189, 2973361, 2973405, 2973700, 2975237, 2975473, 2975637, 2975747, 2975889, 2975925, 2975965, 2976264, 2976605, 2976618, 2976861, 2976868, 2977565, 2977700, 2978333, 3000320, 3001345, 3002378, 3003121, 3003261, 3006468, 3008893, 3008997, 3009028, 3009062, 3010845, 3011045, 3011171, 3011613, 3013635, 3013713, 3013731, 3013765, 3013821, 3014150, 3014237, 3014660, 3211037, 3211268, 3250909, 3252228, 3252541, 3538435, 3538589, 3538595, 3538845, 3538851, 3538941, 3538948, 3548285, 3548740, 3548797, 3549700, 3549821, 3549860, 3549917, 3550340, 3550493, 3550724, 3563421, 3637252, 3640701, 3640836, 3641277, 3641348, 3641661, 3641860, 3642205, 3642261, 3642277, 3642353, 3642394, 3642525, 3792901, 3794397, 3794437, 3795197, 3795477, 3799197, 3801109, 3808989, 3809301, 3810557, 3810613, 3812518, 3812581, 3812693, 3812774, 3812986, 3813221, 3813493, 3813541, 3813781, 3814725, 3814869, 3816829, 3817493, 3819589, 3819701, 3819741, 3823626, 3824285, 3824650, 3825309, 3825685, 3828477, 3828746, 3829565, 3833856, 3834689, 3835520, 3836353, 3836605, 3836609, 3837184, 3838017, 3838848, 3838909, 3838912, 3839005, 3839040, 3839101, 3839136, 3839229, 3839264, 3839421, 3839424, 3839681, 3839837, 3839841, 3839901, 3839905, 3840157, 3840161, 3840512, 3841345, 3842176, 3842269, 3842272, 3842429, 3842464, 3842749, 3842752, 3843005, 3843009, 3843840, 3843933, 3843936, 3844093, 3844096, 3844285, 3844288, 3844349, 3844416, 3844669, 3844673, 3845504, 3846337, 3847168, 3848001, 3848832, 3849665, 3850496, 3851329, 3852160, 3852993, 3853824, 3854657, 3855581, 3855616, 3856434, 3856449, 3857266, 3857281, 3857472, 3858290, 3858305, 3859122, 3859137, 3859328, 3860146, 3860161, 3860978, 3860993, 3861184, 3862002, 3862017, 3862834, 3862849, 3863040, 3863858, 3863873, 3864690, 3864705, 3864896, 3864929, 3864989, 3865032, 3866645, 3883013, 3884789, 3884901, 3886517, 3886757, 3886805, 3887237, 3887285, 3887345, 3887517, 3887973, 3888157, 3888165, 3888669, 3923969, 3924292, 3924321, 3924989, 3925153, 3925373, 3932165, 3932413, 3932421, 3932989, 3933029, 3933277, 3933285, 3933373, 3933381, 3933565, 3933699, 3935709, 3936741, 3936797, 3940356, 3941821, 3941893, 3942115, 3942365, 3942408, 3942749, 3942852, 3942901, 3942941, 3953156, 3954117, 3954173, 3954692, 3956101, 3956232, 3956573, 3956723, 3956765, 3971588, 3972451, 3972485, 3972616, 3972957, 3996676, 3996925, 3996932, 3997085, 3997092, 3997181, 3997188, 3997693, 3997700, 4004029, 4004074, 4004357, 4004605, 4005888, 4006977, 4008069, 4008291, 4008349, 4008456, 4008797, 4008913, 4008989, 4034090, 4035989, 4036010, 4036115, 4036138, 4036285, 4038698, 4040149, 4040170, 4040669, 4046852, 4047005, 4047012, 4047901, 4047908, 4047997, 4048004, 4048061, 4048100, 4048157, 4048164, 4048509, 4048516, 4048669, 4048676, 4048733, 4048740, 4048797, 4048964, 4049021, 4049124, 4049181, 4049188, 4049245, 4049252, 4049309, 4049316, 4049437, 4049444, 4049533, 4049540, 4049597, 4049636, 4049693, 4049700, 4049757, 4049764, 4049821, 4049828, 4049885, 4049892, 4049949, 4049956, 4050045, 4050052, 4050109, 4050148, 4050301, 4050308, 4050557, 4050564, 4050717, 4050724, 4050877, 4050884, 4050941, 4050948, 4051293, 4051300, 4051869, 4052004, 4052125, 4052132, 4052317, 4052324, 4052893, 4054546, 4054621, 4063253, 4064669, 4064789, 4067997, 4068373, 4068861, 4068917, 4069405, 4069429, 4069917, 4069941, 4071133, 4071434, 4071861, 4077021, 4078805, 4079741, 4080149, 4081565, 4081685, 4081981, 4082197, 4082269, 4082709, 4082909, 4087829, 4095860, 4096021, 4119325, 4119445, 4119997, 4120085, 4120509, 4120597, 4124413, 4124533, 4127581, 4127765, 4128157, 4128277, 4128317, 4128789, 4129181, 4129301, 4131101, 4131349, 4131677, 4131861, 4133149, 4133397, 4134365, 4134421, 4134493, 4136981, 4147869, 4148245, 4148701, 4148757, 4149181, 4149269, 4149565, 4149781, 4151261, 4151285, 4151517, 4151765, 4152221, 4152341, 4152637, 4152853, 4153149, 4153365, 4158077, 4158101, 4159869, 4161032, 4161373, 4194308, 5561373, 5562372, 5695325, 5695492, 5702621, 5702660, 5887069, 5887492, 6126653, 6127108, 6147037, 6225924, 6243293, 6291460, 6449533, 6449668, 6583837, 29360186, 29360221, 29361178, 29364253, 29368325, 29376029, 31457308, 33554397, 33554460, 35651549, 35651613, //--Autogenerated -- end of section automatically generated }; constexpr int maxUnicode = 0x10ffff; constexpr int maskCategory = 0x1F; } // Each element in catRanges is the start of a range of Unicode characters in // one general category. // The value is comprised of a 21-bit character value shifted 5 bits and a 5 bit // category matching the CharacterCategory enumeration. // Initial version has 3249 entries and adds about 13K to the executable. // The array is in ascending order so can be searched using binary search. // Therefore the average call takes log2(3249) = 12 comparisons. // For speed, it may be useful to make a linear table for the common values, // possibly for 0..0xff for most Western European text or 0..0xfff for most // alphabetic languages. CharacterCategory CategoriseCharacter(int character) noexcept { if (character < 0 || character > maxUnicode) return ccCn; const int baseValue = character * (maskCategory+1) + maskCategory; try { // lower_bound will never throw with these args but its not marked noexcept so add catch to pretend. const int *placeAfter = std::lower_bound(catRanges, std::end(catRanges), baseValue); return static_cast(*(placeAfter - 1) & maskCategory); } catch (...) { return ccCn; } } // Implementation of character sets recommended for identifiers in Unicode Standard Annex #31. // http://unicode.org/reports/tr31/ namespace { enum class OtherID { oidNone, oidStart, oidContinue }; // Some characters are treated as valid for identifiers even // though most characters from their category are not. // Values copied from http://www.unicode.org/Public/9.0.0/ucd/PropList.txt OtherID OtherIDOfCharacter(int character) noexcept { if ( (character == 0x1885) || // MONGOLIAN LETTER ALI GALI BALUDA (character == 0x1886) || // MONGOLIAN LETTER ALI GALI THREE BALUDA (character == 0x2118) || // SCRIPT CAPITAL P (character == 0x212E) || // ESTIMATED SYMBOL (character == 0x309B) || // KATAKANA-HIRAGANA VOICED SOUND MARK (character == 0x309C)) { // KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK return OtherID::oidStart; } else if ( (character == 0x00B7) || // MIDDLE DOT (character == 0x0387) || // GREEK ANO TELEIA ((character >= 0x1369) && (character <= 0x1371)) || // ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE (character == 0x19DA)) { // NEW TAI LUE THAM DIGIT ONE return OtherID::oidContinue; } else { return OtherID::oidNone; } } // Determine if a character is in Ll|Lu|Lt|Lm|Lo|Nl|Mn|Mc|Nd|Pc and has // Pattern_Syntax|Pattern_White_Space. // As of Unicode 9, only VERTICAL TILDE which is in Lm and has Pattern_Syntax matches. // Should really generate from PropList.txt a list of Pattern_Syntax and Pattern_White_Space. constexpr bool IsIdPattern(int character) noexcept { return character == 0x2E2F; } bool OmitXidStart(int character) noexcept { switch (character) { case 0x037A: // GREEK YPOGEGRAMMENI case 0x0E33: // THAI CHARACTER SARA AM case 0x0EB3: // LAO VOWEL SIGN AM case 0x309B: // KATAKANA-HIRAGANA VOICED SOUND MARK case 0x309C: // KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK case 0xFC5E: // ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM case 0xFC5F: // ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM case 0xFC60: // ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM case 0xFC61: // ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM case 0xFC62: // ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM case 0xFC63: // ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM case 0xFDFA: // ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM case 0xFDFB: // ARABIC LIGATURE JALLAJALALOUHOU case 0xFE70: // ARABIC FATHATAN ISOLATED FORM case 0xFE72: // ARABIC DAMMATAN ISOLATED FORM case 0xFE74: // ARABIC KASRATAN ISOLATED FORM case 0xFE76: // ARABIC FATHA ISOLATED FORM case 0xFE78: // ARABIC DAMMA ISOLATED FORM case 0xFE7A: // ARABIC KASRA ISOLATED FORM case 0xFE7C: // ARABIC SHADDA ISOLATED FORM case 0xFE7E: // ARABIC SUKUN ISOLATED FORM case 0xFF9E: // HALFWIDTH KATAKANA VOICED SOUND MARK case 0xFF9F: // HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK return true; default: return false; } } bool OmitXidContinue(int character) noexcept { switch (character) { case 0x037A: // GREEK YPOGEGRAMMENI case 0x309B: // KATAKANA-HIRAGANA VOICED SOUND MARK case 0x309C: // KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK case 0xFC5E: // ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM case 0xFC5F: // ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM case 0xFC60: // ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM case 0xFC61: // ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM case 0xFC62: // ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM case 0xFC63: // ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM case 0xFDFA: // ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM case 0xFDFB: // ARABIC LIGATURE JALLAJALALOUHOU case 0xFE70: // ARABIC FATHATAN ISOLATED FORM case 0xFE72: // ARABIC DAMMATAN ISOLATED FORM case 0xFE74: // ARABIC KASRATAN ISOLATED FORM case 0xFE76: // ARABIC FATHA ISOLATED FORM case 0xFE78: // ARABIC DAMMA ISOLATED FORM case 0xFE7A: // ARABIC KASRA ISOLATED FORM case 0xFE7C: // ARABIC SHADDA ISOLATED FORM case 0xFE7E: // ARABIC SUKUN ISOLATED FORM return true; default: return false; } } } // UAX #31 defines ID_Start as // [[:L:][:Nl:][:Other_ID_Start:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]] bool IsIdStart(int character) noexcept { if (IsIdPattern(character)) { return false; } const OtherID oid = OtherIDOfCharacter(character); if (oid == OtherID::oidStart) { return true; } const CharacterCategory c = CategoriseCharacter(character); return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo || c == ccNl); } // UAX #31 defines ID_Continue as // [[:ID_Start:][:Mn:][:Mc:][:Nd:][:Pc:][:Other_ID_Continue:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]] bool IsIdContinue(int character) noexcept { if (IsIdPattern(character)) { return false; } const OtherID oid = OtherIDOfCharacter(character); if (oid != OtherID::oidNone) { return true; } const CharacterCategory c = CategoriseCharacter(character); return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo || c == ccNl || c == ccMn || c == ccMc || c == ccNd || c == ccPc); } // XID_Start is ID_Start modified for Normalization Form KC in UAX #31 bool IsXidStart(int character) noexcept { if (OmitXidStart(character)) { return false; } else { return IsIdStart(character); } } // XID_Continue is ID_Continue modified for Normalization Form KC in UAX #31 bool IsXidContinue(int character) noexcept { if (OmitXidContinue(character)) { return false; } else { return IsIdContinue(character); } } CharacterCategoryMap::CharacterCategoryMap() { Optimize(256); } int CharacterCategoryMap::Size() const noexcept { return static_cast(dense.size()); } void CharacterCategoryMap::Optimize(int countCharacters) { const int characters = std::clamp(countCharacters, 256, maxUnicode + 1); dense.resize(characters); int end = 0; int index = 0; int current = catRanges[index]; ++index; do { const int next = catRanges[index]; const unsigned char category = current & maskCategory; current >>= 5; end = std::min(characters, next >> 5); while (current < end) { dense[current++] = category; } current = next; ++index; } while (characters > end); } } tmpok_q575y/lexilla/lexlib/LexerBase.h0000664000175000017500000000462314773064066017512 0ustar gusnangusnan// Scintilla source code edit control /** @file LexerBase.h ** A simple lexer with no state. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXERBASE_H #define LEXERBASE_H namespace Lexilla { // A simple lexer with no state class LexerBase : public Scintilla::ILexer5 { protected: const LexicalClass *lexClasses; size_t nClasses; PropSetSimple props; enum {numWordLists=KEYWORDSET_MAX+1}; WordList *keyWordLists[numWordLists+1]; public: LexerBase(const LexicalClass *lexClasses_=nullptr, size_t nClasses_=0); virtual ~LexerBase(); void SCI_METHOD Release() override; int SCI_METHOD Version() const override; const char * SCI_METHOD PropertyNames() override; int SCI_METHOD PropertyType(const char *name) override; const char * SCI_METHOD DescribeProperty(const char *name) override; Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override; const char * SCI_METHOD DescribeWordListSets() override; Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override; void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override = 0; void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, Scintilla::IDocument *pAccess) override = 0; void * SCI_METHOD PrivateCall(int operation, void *pointer) override; int SCI_METHOD LineEndTypesSupported() override; int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override; int SCI_METHOD SubStylesStart(int styleBase) override; int SCI_METHOD SubStylesLength(int styleBase) override; int SCI_METHOD StyleFromSubStyle(int subStyle) override; int SCI_METHOD PrimaryStyleFromStyle(int style) override; void SCI_METHOD FreeSubStyles() override; void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override; int SCI_METHOD DistanceToSecondaryStyles() override; const char * SCI_METHOD GetSubStyleBases() override; int SCI_METHOD NamedStyles() override; const char * SCI_METHOD NameOfStyle(int style) override; const char * SCI_METHOD TagsOfStyle(int style) override; const char * SCI_METHOD DescriptionOfStyle(int style) override; // ILexer5 methods const char * SCI_METHOD GetName() override; int SCI_METHOD GetIdentifier() override; const char *SCI_METHOD PropertyGet(const char *key) override; }; } #endif tmpok_q575y/lexilla/lexlib/Accessor.h0000664000175000017500000000152414773064066017377 0ustar gusnangusnan// Scintilla source code edit control /** @file Accessor.h ** Interfaces between Scintilla and lexers. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef ACCESSOR_H #define ACCESSOR_H namespace Lexilla { enum { wsSpace=1, wsTab=2, wsSpaceTab=4, wsInconsistent=8 }; class Accessor; class WordList; class PropSetSimple; typedef bool (*PFNIsCommentLeader)(Accessor &styler, Sci_Position pos, Sci_Position len); class Accessor : public LexAccessor { public: PropSetSimple *pprops; Accessor(Scintilla::IDocument *pAccess_, PropSetSimple *pprops_); int GetPropertyInt(std::string_view key, int defaultValue=0) const; int IndentAmount(Sci_Position line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = nullptr); }; } #endif tmpok_q575y/lexilla/lexlib/LexAccessor.cxx0000664000175000017500000000416114773064066020423 0ustar gusnangusnan// Scintilla source code edit control /** @file LexAccessor.cxx ** Interfaces between Scintilla and lexers. **/ // Copyright 1998-2010 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include "ILexer.h" #include "LexAccessor.h" #include "CharacterSet.h" using namespace Lexilla; namespace Lexilla { bool LexAccessor::MatchIgnoreCase(Sci_Position pos, const char *s) { assert(s); for (; *s; s++, pos++) { if (*s != MakeLowerCase(SafeGetCharAt(pos))) { return false; } } return true; } void LexAccessor::GetRange(Sci_PositionU startPos_, Sci_PositionU endPos_, char *s, Sci_PositionU len) const { assert(s); assert(startPos_ <= endPos_ && len != 0); memset(s, '\0', len); endPos_ = std::min(endPos_, startPos_ + len - 1); endPos_ = std::min(endPos_, static_cast(lenDoc)); len = endPos_ - startPos_; if (startPos_ >= static_cast(startPos) && endPos_ <= static_cast(endPos)) { const char * const p = buf + (startPos_ - startPos); memcpy(s, p, len); } else { pAccess->GetCharRange(s, startPos_, len); } } void LexAccessor::GetRangeLowered(Sci_PositionU startPos_, Sci_PositionU endPos_, char *s, Sci_PositionU len) const { assert(s); GetRange(startPos_, endPos_, s, len); while (*s) { if (*s >= 'A' && *s <= 'Z') { *s += 'a' - 'A'; } ++s; } } std::string LexAccessor::GetRange(Sci_PositionU startPos_, Sci_PositionU endPos_) const { assert(startPos_ < endPos_); endPos_ = std::min(endPos_, static_cast(lenDoc)); const Sci_PositionU len = endPos_ - startPos_; std::string s(len, '\0'); GetRange(startPos_, endPos_, s.data(), len + 1); return s; } std::string LexAccessor::GetRangeLowered(Sci_PositionU startPos_, Sci_PositionU endPos_) const { assert(startPos_ < endPos_); endPos_ = std::min(endPos_, static_cast(lenDoc)); const Sci_PositionU len = endPos_ - startPos_; std::string s(len, '\0'); GetRangeLowered(startPos_, endPos_, s.data(), len + 1); return s; } } tmpok_q575y/lexilla/examples/0000775000175000017500000000000014773064066016021 5ustar gusnangusnantmpok_q575y/lexilla/examples/CheckLexilla/0000775000175000017500000000000014773064066020351 5ustar gusnangusnantmpok_q575y/lexilla/examples/CheckLexilla/makefile0000664000175000017500000000056714773064066022061 0ustar gusnangusnan.PHONY: all check clean INCLUDES = -I ../../include EXE = $(if $(windir),CheckLexilla.exe,CheckLexilla) ifdef windir RM = $(if $(wildcard $(dir $(SHELL))rm.exe), $(dir $(SHELL))rm.exe -f, del /q) CC = gcc else LIBS += -ldl endif all: $(EXE) check: $(EXE) ./$(EXE) clean: $(RM) $(EXE) $(EXE): *.c $(CC) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $^ $(LIBS) $(LDLIBS) -o $@ tmpok_q575y/lexilla/examples/CheckLexilla/CheckLexilla.c0000664000175000017500000001021014773064066023037 0ustar gusnangusnan// Lexilla lexer library use example /** @file CheckLexilla.c ** Check that Lexilla.h works. **/ // Copyright 2021 by Neil Hodgson // This file is in the public domain. // If the public domain is not possible in your location then it can also be used under the same // license as Scintilla. https://www.scintilla.org/License.txt /* Build and run Win32 gcc CheckLexilla.c -I ../../include -o CheckLexilla CheckLexilla CheckLexilla ../SimpleLexer/SimpleLexer.dll Win32 Visual C++ cl CheckLexilla.c -I ../../include -Fe: CheckLexilla CheckLexilla CheckLexilla ../SimpleLexer/SimpleLexer.dll macOS clang CheckLexilla.c -I ../../include -o CheckLexilla ./CheckLexilla ./CheckLexilla ../SimpleLexer/SimpleLexer.dylib Linux gcc CheckLexilla.c -I ../../include -ldl -o CheckLexilla ./CheckLexilla ./CheckLexilla ../SimpleLexer/SimpleLexer.so While principally meant for compilation as C to act as an example of using Lexilla from C it can also be built as C++. Warnings are intentionally shown for the deprecated typedef LexerNameFromIDFn when compiled with GCC or Clang or as C++. */ #include #if defined(_WIN32) #include #else #include #endif #if defined(__cplusplus) #include "ILexer.h" #endif #include "Lexilla.h" #if defined(__cplusplus) using namespace Lexilla; #endif #if defined(_WIN32) typedef FARPROC Function; typedef HMODULE Module; #else typedef void *Function; typedef void *Module; #endif static Function FindSymbol(Module m, const char *symbol) { #if defined(_WIN32) return GetProcAddress(m, symbol); #else return dlsym(m, symbol); #endif } int main(int argc, char *argv[]) { char szLexillaPath[] = "../../bin/" LEXILLA_LIB LEXILLA_EXTENSION; const char *libPath = szLexillaPath; if (argc > 1) { libPath = argv[1]; } #if defined(_WIN32) Module lexillaLibrary = LoadLibraryA(libPath); #else Module lexillaLibrary = dlopen(libPath, RTLD_LAZY); #endif printf("Opened %s -> %p.\n", libPath, lexillaLibrary); if (lexillaLibrary) { GetLexerCountFn lexerCount = (GetLexerCountFn)FindSymbol(lexillaLibrary, LEXILLA_GETLEXERCOUNT); if (lexerCount) { int nLexers = lexerCount(); printf("There are %d lexers.\n", nLexers); GetLexerNameFn lexerName = (GetLexerNameFn)FindSymbol(lexillaLibrary, LEXILLA_GETLEXERNAME); for (int i = 0; i < nLexers; i++) { char name[100] = ""; lexerName(i, name, sizeof(name)); printf("%s ", name); } printf("\n"); GetLexerFactoryFn lexerFactory = (GetLexerFactoryFn)FindSymbol(lexillaLibrary, LEXILLA_GETLEXERFACTORY); LexerFactoryFunction lexerFactory4 = lexerFactory(4); // 4th entry is "as" which is an object lexer so works printf("Lexer factory 4 -> %p.\n", lexerFactory4); CreateLexerFn lexerCreate = (CreateLexerFn)FindSymbol(lexillaLibrary, LEXILLA_CREATELEXER); ILexer5 *lexerCpp = lexerCreate("cpp"); printf("Created cpp lexer -> %p.\n", lexerCpp); LexerNameFromIDFn lexerNameFromID = (LexerNameFromIDFn)FindSymbol(lexillaLibrary, LEXILLA_LEXERNAMEFROMID); if (lexerNameFromID) { const char *lexerNameCpp = lexerNameFromID(3); // SCLEX_CPP=3 if (lexerNameCpp) { printf("Lexer name 3 -> %s.\n", lexerNameCpp); } else { printf("Lexer name 3 not available.\n"); } } else { printf("Lexer name from ID not supported.\n"); } GetLibraryPropertyNamesFn libraryProperties = (GetLibraryPropertyNamesFn)FindSymbol(lexillaLibrary, LEXILLA_GETLIBRARYPROPERTYNAMES); if (libraryProperties) { const char *names = libraryProperties(); printf("Property names '%s'.\n", names); } else { printf("Property names not supported.\n"); } SetLibraryPropertyFn librarySetProperty = (SetLibraryPropertyFn)FindSymbol(lexillaLibrary, LEXILLA_SETLIBRARYPROPERTY); if (librarySetProperty) { librarySetProperty("key", "value"); } else { printf("Set property not supported.\n"); } GetNameSpaceFn libraryNameSpace = (GetLibraryPropertyNamesFn)FindSymbol(lexillaLibrary, LEXILLA_GETNAMESPACE); if (libraryNameSpace) { const char *nameSpace = libraryNameSpace(); printf("Name space '%s'.\n", nameSpace); } else { printf("Name space not supported.\n"); } } } } tmpok_q575y/lexilla/examples/SimpleLexer/0000775000175000017500000000000014773064066020252 5ustar gusnangusnantmpok_q575y/lexilla/examples/SimpleLexer/makefile0000664000175000017500000000214614773064066021755 0ustar gusnangusnan.PHONY: all check clean INCLUDES = -I ../../../scintilla/include -I ../../include -I ../../lexlib BASE_FLAGS += --std=c++17 ifdef windir SHAREDEXTENSION = dll else ifeq ($(shell uname),Darwin) SHAREDEXTENSION = dylib BASE_FLAGS += -arch arm64 -arch x86_64 LINK_FLAGS += -dynamiclib else BASE_FLAGS += -fPIC SHAREDEXTENSION = so endif BASE_FLAGS += -fvisibility=hidden endif ifdef windir RM = $(if $(wildcard $(dir $(SHELL))rm.exe), $(dir $(SHELL))rm.exe -f, del /q) CXX = g++ endif LIBRARY = SimpleLexer.$(SHAREDEXTENSION) vpath %.cxx ../../lexlib LEXLIB_SOURCES := $(sort $(notdir $(wildcard ../../lexlib/*.cxx))) LEXLIB = $(LEXLIB_SOURCES:.cxx=.o) %.o: %.cxx $(CXX) $(INCLUDES) $(BASE_FLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ all: $(LIBRARY) # make check requires CheckLexilla to have already been built check: $(LIBRARY) ../CheckLexilla/CheckLexilla ./$(LIBRARY) clean: $(RM) *.o *obj *.lib *.exp $(LIBRARY) $(LIBRARY): $(LEXLIB) *.cxx $(CXX) $(INCLUDES) $(LINK_FLAGS) $(BASE_FLAGS) -shared $(CPPFLAGS) $(CXXFLAGS) $^ $(LIBS) $(LDLIBS) -o $@ tmpok_q575y/lexilla/examples/SimpleLexer/SimpleLexer.cxx0000664000175000017500000000765114773064066023240 0ustar gusnangusnan// A simple lexer /** @file SimpleLexer.cxx ** A lexer that follows the Lexilla protocol to allow it to be used from Lexilla clients like SciTE. ** The lexer applies alternating styles (0,1) to bytes of the text. **/ // Copyright 2021 by Neil Hodgson // This file is in the public domain. // If the public domain is not possible in your location then it can also be used under the same // license as Scintilla. https://www.scintilla.org/License.txt // Windows/MSVC // cl -std:c++17 -EHsc -LD -I ../../../scintilla/include -I ../../include -I ../../lexlib SimpleLexer.cxx ../../lexlib/*.cxx // macOS/clang // clang++ -dynamiclib --std=c++17 -I ../../../scintilla/include -I ../../include -I ../../lexlib SimpleLexer.cxx ../../lexlib/*.cxx -o SimpleLexer.dylib // Linux/g++ // g++ -fPIC -shared --std=c++17 -I ../../../scintilla/include -I ../../include -I ../../lexlib SimpleLexer.cxx ../../lexlib/*.cxx -o SimpleLexer.so /* It can be demonstrated in SciTE like this, substituting the actual shared library location as lexilla.path: lexilla.path=.;C:\u\hg\lexilla\examples\SimpleLexer\SimpleLexer.dll lexer.*.xx=simple style.simple.1=fore:#FF0000 */ #include #include #include #include #include #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" // Lexilla.h should not be included here as it declares statically linked functions without the __declspec( dllexport ) #include "WordList.h" #include "PropSetSimple.h" #include "LexAccessor.h" #include "Accessor.h" #include "StyleContext.h" #include "CharacterSet.h" #include "LexerModule.h" #include "LexerBase.h" using namespace Scintilla; using namespace Lexilla; class LexerSimple : public LexerBase { public: LexerSimple() { } void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override { try { Accessor astyler(pAccess, &props); if (length > 0) { astyler.StartAt(startPos); astyler.StartSegment(startPos); for (unsigned int k=0; kSetErrorStatus(SC_STATUS_FAILURE); } } void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override { } static ILexer5 *LexerFactorySimple() { try { return new LexerSimple(); } catch (...) { // Should not throw into caller as may be compiled with different compiler or options return nullptr; } } }; #if defined(_WIN32) #define EXPORT_FUNCTION __declspec(dllexport) #define CALLING_CONVENTION __stdcall #else #define EXPORT_FUNCTION __attribute__((visibility("default"))) #define CALLING_CONVENTION #endif static const char *lexerName = "simple"; extern "C" { EXPORT_FUNCTION int CALLING_CONVENTION GetLexerCount() { return 1; } EXPORT_FUNCTION void CALLING_CONVENTION GetLexerName(unsigned int index, char *name, int buflength) { *name = 0; if ((index == 0) && (buflength > static_cast(strlen(lexerName)))) { strcpy(name, lexerName); } } EXPORT_FUNCTION LexerFactoryFunction CALLING_CONVENTION GetLexerFactory(unsigned int index) { if (index == 0) return LexerSimple::LexerFactorySimple; else return 0; } EXPORT_FUNCTION Scintilla::ILexer5* CALLING_CONVENTION CreateLexer(const char *name) { if (0 == strcmp(name, lexerName)) { return LexerSimple::LexerFactorySimple(); } return nullptr; } EXPORT_FUNCTION const char * CALLING_CONVENTION GetNameSpace() { return "example"; } } tmpok_q575y/lexilla/include/0000775000175000017500000000000014773064066015626 5ustar gusnangusnantmpok_q575y/lexilla/include/LexicalStyles.iface0000664000175000017500000017176514773064066021425 0ustar gusnangusnan## This file defines the interface to Lexilla ## Copyright 2000-2020 by Neil Hodgson ## The License.txt file describes the conditions under which this software may be distributed. ## Similar file structure as Scintilla.iface but only contains constants. cat Default ################################################ # For SciLexer.h enu Lexer=SCLEX_ val SCLEX_CONTAINER=0 val SCLEX_NULL=1 val SCLEX_PYTHON=2 val SCLEX_CPP=3 val SCLEX_HTML=4 val SCLEX_XML=5 val SCLEX_PERL=6 val SCLEX_SQL=7 val SCLEX_VB=8 val SCLEX_PROPERTIES=9 val SCLEX_ERRORLIST=10 val SCLEX_MAKEFILE=11 val SCLEX_BATCH=12 val SCLEX_XCODE=13 val SCLEX_LATEX=14 val SCLEX_LUA=15 val SCLEX_DIFF=16 val SCLEX_CONF=17 val SCLEX_PASCAL=18 val SCLEX_AVE=19 val SCLEX_ADA=20 val SCLEX_LISP=21 val SCLEX_RUBY=22 val SCLEX_EIFFEL=23 val SCLEX_EIFFELKW=24 val SCLEX_TCL=25 val SCLEX_NNCRONTAB=26 val SCLEX_BULLANT=27 val SCLEX_VBSCRIPT=28 val SCLEX_BAAN=31 val SCLEX_MATLAB=32 val SCLEX_SCRIPTOL=33 val SCLEX_ASM=34 val SCLEX_CPPNOCASE=35 val SCLEX_FORTRAN=36 val SCLEX_F77=37 val SCLEX_CSS=38 val SCLEX_POV=39 val SCLEX_LOUT=40 val SCLEX_ESCRIPT=41 val SCLEX_PS=42 val SCLEX_NSIS=43 val SCLEX_MMIXAL=44 val SCLEX_CLW=45 val SCLEX_CLWNOCASE=46 val SCLEX_LOT=47 val SCLEX_YAML=48 val SCLEX_TEX=49 val SCLEX_METAPOST=50 val SCLEX_POWERBASIC=51 val SCLEX_FORTH=52 val SCLEX_ERLANG=53 val SCLEX_OCTAVE=54 val SCLEX_MSSQL=55 val SCLEX_VERILOG=56 val SCLEX_KIX=57 val SCLEX_GUI4CLI=58 val SCLEX_SPECMAN=59 val SCLEX_AU3=60 val SCLEX_APDL=61 val SCLEX_BASH=62 val SCLEX_ASN1=63 val SCLEX_VHDL=64 val SCLEX_CAML=65 val SCLEX_BLITZBASIC=66 val SCLEX_PUREBASIC=67 val SCLEX_HASKELL=68 val SCLEX_PHPSCRIPT=69 val SCLEX_TADS3=70 val SCLEX_REBOL=71 val SCLEX_SMALLTALK=72 val SCLEX_FLAGSHIP=73 val SCLEX_CSOUND=74 val SCLEX_FREEBASIC=75 val SCLEX_INNOSETUP=76 val SCLEX_OPAL=77 val SCLEX_SPICE=78 val SCLEX_D=79 val SCLEX_CMAKE=80 val SCLEX_GAP=81 val SCLEX_PLM=82 val SCLEX_PROGRESS=83 val SCLEX_ABAQUS=84 val SCLEX_ASYMPTOTE=85 val SCLEX_R=86 val SCLEX_MAGIK=87 val SCLEX_POWERSHELL=88 val SCLEX_MYSQL=89 val SCLEX_PO=90 val SCLEX_TAL=91 val SCLEX_COBOL=92 val SCLEX_TACL=93 val SCLEX_SORCUS=94 val SCLEX_POWERPRO=95 val SCLEX_NIMROD=96 val SCLEX_SML=97 val SCLEX_MARKDOWN=98 val SCLEX_TXT2TAGS=99 val SCLEX_A68K=100 val SCLEX_MODULA=101 val SCLEX_COFFEESCRIPT=102 val SCLEX_TCMD=103 val SCLEX_AVS=104 val SCLEX_ECL=105 val SCLEX_OSCRIPT=106 val SCLEX_VISUALPROLOG=107 val SCLEX_LITERATEHASKELL=108 val SCLEX_STTXT=109 val SCLEX_KVIRC=110 val SCLEX_RUST=111 val SCLEX_DMAP=112 val SCLEX_AS=113 val SCLEX_DMIS=114 val SCLEX_REGISTRY=115 val SCLEX_BIBTEX=116 val SCLEX_SREC=117 val SCLEX_IHEX=118 val SCLEX_TEHEX=119 val SCLEX_JSON=120 val SCLEX_EDIFACT=121 val SCLEX_INDENT=122 val SCLEX_MAXIMA=123 val SCLEX_STATA=124 val SCLEX_SAS=125 val SCLEX_NIM=126 val SCLEX_CIL=127 val SCLEX_X12=128 val SCLEX_DATAFLEX=129 val SCLEX_HOLLYWOOD=130 val SCLEX_RAKU=131 val SCLEX_FSHARP=132 val SCLEX_JULIA=133 val SCLEX_ASCIIDOC=134 val SCLEX_GDSCRIPT=135 val SCLEX_TOML=136 val SCLEX_TROFF=137 val SCLEX_DART=138 val SCLEX_ZIG=139 val SCLEX_NIX=140 # When a lexer specifies its language as SCLEX_AUTOMATIC it receives a # value assigned in sequence from SCLEX_AUTOMATIC+1. val SCLEX_AUTOMATIC=1000 # Lexical states for SCLEX_PYTHON lex Python=SCLEX_PYTHON SCE_P_ lex Nimrod=SCLEX_NIMROD SCE_P_ val SCE_P_DEFAULT=0 val SCE_P_COMMENTLINE=1 val SCE_P_NUMBER=2 val SCE_P_STRING=3 val SCE_P_CHARACTER=4 val SCE_P_WORD=5 val SCE_P_TRIPLE=6 val SCE_P_TRIPLEDOUBLE=7 val SCE_P_CLASSNAME=8 val SCE_P_DEFNAME=9 val SCE_P_OPERATOR=10 val SCE_P_IDENTIFIER=11 val SCE_P_COMMENTBLOCK=12 val SCE_P_STRINGEOL=13 val SCE_P_WORD2=14 val SCE_P_DECORATOR=15 val SCE_P_FSTRING=16 val SCE_P_FCHARACTER=17 val SCE_P_FTRIPLE=18 val SCE_P_FTRIPLEDOUBLE=19 val SCE_P_ATTRIBUTE=20 # Lexical states for SCLEX_CPP # Lexical states for SCLEX_BULLANT # Lexical states for SCLEX_TACL # Lexical states for SCLEX_TAL lex Cpp=SCLEX_CPP SCE_C_ lex BullAnt=SCLEX_BULLANT SCE_C_ lex TACL=SCLEX_TACL SCE_C_ lex TAL=SCLEX_TAL SCE_C_ val SCE_C_DEFAULT=0 val SCE_C_COMMENT=1 val SCE_C_COMMENTLINE=2 val SCE_C_COMMENTDOC=3 val SCE_C_NUMBER=4 val SCE_C_WORD=5 val SCE_C_STRING=6 val SCE_C_CHARACTER=7 val SCE_C_UUID=8 val SCE_C_PREPROCESSOR=9 val SCE_C_OPERATOR=10 val SCE_C_IDENTIFIER=11 val SCE_C_STRINGEOL=12 val SCE_C_VERBATIM=13 val SCE_C_REGEX=14 val SCE_C_COMMENTLINEDOC=15 val SCE_C_WORD2=16 val SCE_C_COMMENTDOCKEYWORD=17 val SCE_C_COMMENTDOCKEYWORDERROR=18 val SCE_C_GLOBALCLASS=19 val SCE_C_STRINGRAW=20 val SCE_C_TRIPLEVERBATIM=21 val SCE_C_HASHQUOTEDSTRING=22 val SCE_C_PREPROCESSORCOMMENT=23 val SCE_C_PREPROCESSORCOMMENTDOC=24 val SCE_C_USERLITERAL=25 val SCE_C_TASKMARKER=26 val SCE_C_ESCAPESEQUENCE=27 # Lexical states for SCLEX_COBOL lex COBOL=SCLEX_COBOL SCE_COBOL_ val SCE_COBOL_DEFAULT=0 val SCE_COBOL_COMMENT=1 val SCE_COBOL_COMMENTLINE=2 val SCE_COBOL_COMMENTDOC=3 val SCE_COBOL_NUMBER=4 val SCE_COBOL_WORD=5 val SCE_COBOL_STRING=6 val SCE_COBOL_CHARACTER=7 val SCE_COBOL_WORD3=8 val SCE_COBOL_PREPROCESSOR=9 val SCE_COBOL_OPERATOR=10 val SCE_COBOL_IDENTIFIER=11 val SCE_COBOL_WORD2=16 # Lexical states for SCLEX_D lex D=SCLEX_D SCE_D_ val SCE_D_DEFAULT=0 val SCE_D_COMMENT=1 val SCE_D_COMMENTLINE=2 val SCE_D_COMMENTDOC=3 val SCE_D_COMMENTNESTED=4 val SCE_D_NUMBER=5 val SCE_D_WORD=6 val SCE_D_WORD2=7 val SCE_D_WORD3=8 val SCE_D_TYPEDEF=9 val SCE_D_STRING=10 val SCE_D_STRINGEOL=11 val SCE_D_CHARACTER=12 val SCE_D_OPERATOR=13 val SCE_D_IDENTIFIER=14 val SCE_D_COMMENTLINEDOC=15 val SCE_D_COMMENTDOCKEYWORD=16 val SCE_D_COMMENTDOCKEYWORDERROR=17 val SCE_D_STRINGB=18 val SCE_D_STRINGR=19 val SCE_D_WORD5=20 val SCE_D_WORD6=21 val SCE_D_WORD7=22 # Lexical states for SCLEX_TCL lex TCL=SCLEX_TCL SCE_TCL_ val SCE_TCL_DEFAULT=0 val SCE_TCL_COMMENT=1 val SCE_TCL_COMMENTLINE=2 val SCE_TCL_NUMBER=3 val SCE_TCL_WORD_IN_QUOTE=4 val SCE_TCL_IN_QUOTE=5 val SCE_TCL_OPERATOR=6 val SCE_TCL_IDENTIFIER=7 val SCE_TCL_SUBSTITUTION=8 val SCE_TCL_SUB_BRACE=9 val SCE_TCL_MODIFIER=10 val SCE_TCL_EXPAND=11 val SCE_TCL_WORD=12 val SCE_TCL_WORD2=13 val SCE_TCL_WORD3=14 val SCE_TCL_WORD4=15 val SCE_TCL_WORD5=16 val SCE_TCL_WORD6=17 val SCE_TCL_WORD7=18 val SCE_TCL_WORD8=19 val SCE_TCL_COMMENT_BOX=20 val SCE_TCL_BLOCK_COMMENT=21 # Lexical states for SCLEX_HTML, SCLEX_XML lex HTML=SCLEX_HTML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_ lex XML=SCLEX_XML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_ val SCE_H_DEFAULT=0 val SCE_H_TAG=1 val SCE_H_TAGUNKNOWN=2 val SCE_H_ATTRIBUTE=3 val SCE_H_ATTRIBUTEUNKNOWN=4 val SCE_H_NUMBER=5 val SCE_H_DOUBLESTRING=6 val SCE_H_SINGLESTRING=7 val SCE_H_OTHER=8 val SCE_H_COMMENT=9 val SCE_H_ENTITY=10 # XML and ASP val SCE_H_TAGEND=11 val SCE_H_XMLSTART=12 val SCE_H_XMLEND=13 val SCE_H_SCRIPT=14 val SCE_H_ASP=15 val SCE_H_ASPAT=16 val SCE_H_CDATA=17 val SCE_H_QUESTION=18 # More HTML val SCE_H_VALUE=19 # X-Code, ASP.NET, JSP val SCE_H_XCCOMMENT=20 # SGML val SCE_H_SGML_DEFAULT=21 val SCE_H_SGML_COMMAND=22 val SCE_H_SGML_1ST_PARAM=23 val SCE_H_SGML_DOUBLESTRING=24 val SCE_H_SGML_SIMPLESTRING=25 val SCE_H_SGML_ERROR=26 val SCE_H_SGML_SPECIAL=27 val SCE_H_SGML_ENTITY=28 val SCE_H_SGML_COMMENT=29 val SCE_H_SGML_1ST_PARAM_COMMENT=30 val SCE_H_SGML_BLOCK_DEFAULT=31 # Embedded Javascript val SCE_HJ_START=40 val SCE_HJ_DEFAULT=41 val SCE_HJ_COMMENT=42 val SCE_HJ_COMMENTLINE=43 val SCE_HJ_COMMENTDOC=44 val SCE_HJ_NUMBER=45 val SCE_HJ_WORD=46 val SCE_HJ_KEYWORD=47 val SCE_HJ_DOUBLESTRING=48 val SCE_HJ_SINGLESTRING=49 val SCE_HJ_SYMBOLS=50 val SCE_HJ_STRINGEOL=51 val SCE_HJ_REGEX=52 val SCE_HJ_TEMPLATELITERAL=53 # ASP Javascript val SCE_HJA_START=55 val SCE_HJA_DEFAULT=56 val SCE_HJA_COMMENT=57 val SCE_HJA_COMMENTLINE=58 val SCE_HJA_COMMENTDOC=59 val SCE_HJA_NUMBER=60 val SCE_HJA_WORD=61 val SCE_HJA_KEYWORD=62 val SCE_HJA_DOUBLESTRING=63 val SCE_HJA_SINGLESTRING=64 val SCE_HJA_SYMBOLS=65 val SCE_HJA_STRINGEOL=66 val SCE_HJA_REGEX=67 val SCE_HJA_TEMPLATELITERAL=68 # Embedded VBScript val SCE_HB_START=70 val SCE_HB_DEFAULT=71 val SCE_HB_COMMENTLINE=72 val SCE_HB_NUMBER=73 val SCE_HB_WORD=74 val SCE_HB_STRING=75 val SCE_HB_IDENTIFIER=76 val SCE_HB_STRINGEOL=77 # ASP VBScript val SCE_HBA_START=80 val SCE_HBA_DEFAULT=81 val SCE_HBA_COMMENTLINE=82 val SCE_HBA_NUMBER=83 val SCE_HBA_WORD=84 val SCE_HBA_STRING=85 val SCE_HBA_IDENTIFIER=86 val SCE_HBA_STRINGEOL=87 # Embedded Python val SCE_HP_START=90 val SCE_HP_DEFAULT=91 val SCE_HP_COMMENTLINE=92 val SCE_HP_NUMBER=93 val SCE_HP_STRING=94 val SCE_HP_CHARACTER=95 val SCE_HP_WORD=96 val SCE_HP_TRIPLE=97 val SCE_HP_TRIPLEDOUBLE=98 val SCE_HP_CLASSNAME=99 val SCE_HP_DEFNAME=100 val SCE_HP_OPERATOR=101 val SCE_HP_IDENTIFIER=102 # PHP val SCE_HPHP_COMPLEX_VARIABLE=104 # ASP Python val SCE_HPA_START=105 val SCE_HPA_DEFAULT=106 val SCE_HPA_COMMENTLINE=107 val SCE_HPA_NUMBER=108 val SCE_HPA_STRING=109 val SCE_HPA_CHARACTER=110 val SCE_HPA_WORD=111 val SCE_HPA_TRIPLE=112 val SCE_HPA_TRIPLEDOUBLE=113 val SCE_HPA_CLASSNAME=114 val SCE_HPA_DEFNAME=115 val SCE_HPA_OPERATOR=116 val SCE_HPA_IDENTIFIER=117 # PHP val SCE_HPHP_DEFAULT=118 val SCE_HPHP_HSTRING=119 val SCE_HPHP_SIMPLESTRING=120 val SCE_HPHP_WORD=121 val SCE_HPHP_NUMBER=122 val SCE_HPHP_VARIABLE=123 val SCE_HPHP_COMMENT=124 val SCE_HPHP_COMMENTLINE=125 val SCE_HPHP_HSTRING_VARIABLE=126 val SCE_HPHP_OPERATOR=127 # Lexical states for SCLEX_PERL lex Perl=SCLEX_PERL SCE_PL_ val SCE_PL_DEFAULT=0 val SCE_PL_ERROR=1 val SCE_PL_COMMENTLINE=2 val SCE_PL_POD=3 val SCE_PL_NUMBER=4 val SCE_PL_WORD=5 val SCE_PL_STRING=6 val SCE_PL_CHARACTER=7 val SCE_PL_PUNCTUATION=8 val SCE_PL_PREPROCESSOR=9 val SCE_PL_OPERATOR=10 val SCE_PL_IDENTIFIER=11 val SCE_PL_SCALAR=12 val SCE_PL_ARRAY=13 val SCE_PL_HASH=14 val SCE_PL_SYMBOLTABLE=15 val SCE_PL_VARIABLE_INDEXER=16 val SCE_PL_REGEX=17 val SCE_PL_REGSUBST=18 val SCE_PL_LONGQUOTE=19 val SCE_PL_BACKTICKS=20 val SCE_PL_DATASECTION=21 val SCE_PL_HERE_DELIM=22 val SCE_PL_HERE_Q=23 val SCE_PL_HERE_QQ=24 val SCE_PL_HERE_QX=25 val SCE_PL_STRING_Q=26 val SCE_PL_STRING_QQ=27 val SCE_PL_STRING_QX=28 val SCE_PL_STRING_QR=29 val SCE_PL_STRING_QW=30 val SCE_PL_POD_VERB=31 val SCE_PL_SUB_PROTOTYPE=40 val SCE_PL_FORMAT_IDENT=41 val SCE_PL_FORMAT=42 val SCE_PL_STRING_VAR=43 val SCE_PL_XLAT=44 val SCE_PL_REGEX_VAR=54 val SCE_PL_REGSUBST_VAR=55 val SCE_PL_BACKTICKS_VAR=57 val SCE_PL_HERE_QQ_VAR=61 val SCE_PL_HERE_QX_VAR=62 val SCE_PL_STRING_QQ_VAR=64 val SCE_PL_STRING_QX_VAR=65 val SCE_PL_STRING_QR_VAR=66 # Lexical states for SCLEX_RUBY lex Ruby=SCLEX_RUBY SCE_RB_ val SCE_RB_DEFAULT=0 val SCE_RB_ERROR=1 val SCE_RB_COMMENTLINE=2 val SCE_RB_POD=3 val SCE_RB_NUMBER=4 val SCE_RB_WORD=5 val SCE_RB_STRING=6 val SCE_RB_CHARACTER=7 val SCE_RB_CLASSNAME=8 val SCE_RB_DEFNAME=9 val SCE_RB_OPERATOR=10 val SCE_RB_IDENTIFIER=11 val SCE_RB_REGEX=12 val SCE_RB_GLOBAL=13 val SCE_RB_SYMBOL=14 val SCE_RB_MODULE_NAME=15 val SCE_RB_INSTANCE_VAR=16 val SCE_RB_CLASS_VAR=17 val SCE_RB_BACKTICKS=18 val SCE_RB_DATASECTION=19 val SCE_RB_HERE_DELIM=20 val SCE_RB_HERE_Q=21 val SCE_RB_HERE_QQ=22 val SCE_RB_HERE_QX=23 val SCE_RB_STRING_Q=24 val SCE_RB_STRING_QQ=25 val SCE_RB_STRING_QX=26 val SCE_RB_STRING_QR=27 val SCE_RB_STRING_QW=28 val SCE_RB_WORD_DEMOTED=29 val SCE_RB_STDIN=30 val SCE_RB_STDOUT=31 val SCE_RB_STDERR=40 val SCE_RB_STRING_W=41 val SCE_RB_STRING_I=42 val SCE_RB_STRING_QI=43 val SCE_RB_STRING_QS=44 val SCE_RB_UPPER_BOUND=45 # Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC, SCLEX_BLITZBASIC, SCLEX_PUREBASIC, SCLEX_FREEBASIC lex VB=SCLEX_VB SCE_B_ lex VBScript=SCLEX_VBSCRIPT SCE_B_ lex PowerBasic=SCLEX_POWERBASIC SCE_B_ lex BlitzBasic=SCLEX_BLITZBASIC SCE_B_ lex PureBasic=SCLEX_PUREBASIC SCE_B_ lex FreeBasic=SCLEX_FREEBASIC SCE_B_ val SCE_B_DEFAULT=0 val SCE_B_COMMENT=1 val SCE_B_NUMBER=2 val SCE_B_KEYWORD=3 val SCE_B_STRING=4 val SCE_B_PREPROCESSOR=5 val SCE_B_OPERATOR=6 val SCE_B_IDENTIFIER=7 val SCE_B_DATE=8 val SCE_B_STRINGEOL=9 val SCE_B_KEYWORD2=10 val SCE_B_KEYWORD3=11 val SCE_B_KEYWORD4=12 val SCE_B_CONSTANT=13 val SCE_B_ASM=14 val SCE_B_LABEL=15 val SCE_B_ERROR=16 val SCE_B_HEXNUMBER=17 val SCE_B_BINNUMBER=18 val SCE_B_COMMENTBLOCK=19 val SCE_B_DOCLINE=20 val SCE_B_DOCBLOCK=21 val SCE_B_DOCKEYWORD=22 # Lexical states for SCLEX_PROPERTIES lex Properties=SCLEX_PROPERTIES SCE_PROPS_ val SCE_PROPS_DEFAULT=0 val SCE_PROPS_COMMENT=1 val SCE_PROPS_SECTION=2 val SCE_PROPS_ASSIGNMENT=3 val SCE_PROPS_DEFVAL=4 val SCE_PROPS_KEY=5 # Lexical states for SCLEX_LATEX lex LaTeX=SCLEX_LATEX SCE_L_ val SCE_L_DEFAULT=0 val SCE_L_COMMAND=1 val SCE_L_TAG=2 val SCE_L_MATH=3 val SCE_L_COMMENT=4 val SCE_L_TAG2=5 val SCE_L_MATH2=6 val SCE_L_COMMENT2=7 val SCE_L_VERBATIM=8 val SCE_L_SHORTCMD=9 val SCE_L_SPECIAL=10 val SCE_L_CMDOPT=11 val SCE_L_ERROR=12 # Lexical states for SCLEX_LUA lex Lua=SCLEX_LUA SCE_LUA_ val SCE_LUA_DEFAULT=0 val SCE_LUA_COMMENT=1 val SCE_LUA_COMMENTLINE=2 val SCE_LUA_COMMENTDOC=3 val SCE_LUA_NUMBER=4 val SCE_LUA_WORD=5 val SCE_LUA_STRING=6 val SCE_LUA_CHARACTER=7 val SCE_LUA_LITERALSTRING=8 val SCE_LUA_PREPROCESSOR=9 val SCE_LUA_OPERATOR=10 val SCE_LUA_IDENTIFIER=11 val SCE_LUA_STRINGEOL=12 val SCE_LUA_WORD2=13 val SCE_LUA_WORD3=14 val SCE_LUA_WORD4=15 val SCE_LUA_WORD5=16 val SCE_LUA_WORD6=17 val SCE_LUA_WORD7=18 val SCE_LUA_WORD8=19 val SCE_LUA_LABEL=20 # Lexical states for SCLEX_ERRORLIST lex ErrorList=SCLEX_ERRORLIST SCE_ERR_ val SCE_ERR_DEFAULT=0 val SCE_ERR_PYTHON=1 val SCE_ERR_GCC=2 val SCE_ERR_MS=3 val SCE_ERR_CMD=4 val SCE_ERR_BORLAND=5 val SCE_ERR_PERL=6 val SCE_ERR_NET=7 val SCE_ERR_LUA=8 val SCE_ERR_CTAG=9 val SCE_ERR_DIFF_CHANGED=10 val SCE_ERR_DIFF_ADDITION=11 val SCE_ERR_DIFF_DELETION=12 val SCE_ERR_DIFF_MESSAGE=13 val SCE_ERR_PHP=14 val SCE_ERR_ELF=15 val SCE_ERR_IFC=16 val SCE_ERR_IFORT=17 val SCE_ERR_ABSF=18 val SCE_ERR_TIDY=19 val SCE_ERR_JAVA_STACK=20 val SCE_ERR_VALUE=21 val SCE_ERR_GCC_INCLUDED_FROM=22 val SCE_ERR_ESCSEQ=23 val SCE_ERR_ESCSEQ_UNKNOWN=24 val SCE_ERR_GCC_EXCERPT=25 val SCE_ERR_BASH=26 val SCE_ERR_ES_BLACK=40 val SCE_ERR_ES_RED=41 val SCE_ERR_ES_GREEN=42 val SCE_ERR_ES_BROWN=43 val SCE_ERR_ES_BLUE=44 val SCE_ERR_ES_MAGENTA=45 val SCE_ERR_ES_CYAN=46 val SCE_ERR_ES_GRAY=47 val SCE_ERR_ES_DARK_GRAY=48 val SCE_ERR_ES_BRIGHT_RED=49 val SCE_ERR_ES_BRIGHT_GREEN=50 val SCE_ERR_ES_YELLOW=51 val SCE_ERR_ES_BRIGHT_BLUE=52 val SCE_ERR_ES_BRIGHT_MAGENTA=53 val SCE_ERR_ES_BRIGHT_CYAN=54 val SCE_ERR_ES_WHITE=55 # Lexical states for SCLEX_BATCH lex Batch=SCLEX_BATCH SCE_BAT_ val SCE_BAT_DEFAULT=0 val SCE_BAT_COMMENT=1 val SCE_BAT_WORD=2 val SCE_BAT_LABEL=3 val SCE_BAT_HIDE=4 val SCE_BAT_COMMAND=5 val SCE_BAT_IDENTIFIER=6 val SCE_BAT_OPERATOR=7 val SCE_BAT_AFTER_LABEL=8 # Lexical states for SCLEX_TCMD lex TCMD=SCLEX_TCMD SCE_TCMD_ val SCE_TCMD_DEFAULT=0 val SCE_TCMD_COMMENT=1 val SCE_TCMD_WORD=2 val SCE_TCMD_LABEL=3 val SCE_TCMD_HIDE=4 val SCE_TCMD_COMMAND=5 val SCE_TCMD_IDENTIFIER=6 val SCE_TCMD_OPERATOR=7 val SCE_TCMD_ENVIRONMENT=8 val SCE_TCMD_EXPANSION=9 val SCE_TCMD_CLABEL=10 # Lexical states for SCLEX_MAKEFILE lex MakeFile=SCLEX_MAKEFILE SCE_MAKE_ val SCE_MAKE_DEFAULT=0 val SCE_MAKE_COMMENT=1 val SCE_MAKE_PREPROCESSOR=2 val SCE_MAKE_IDENTIFIER=3 val SCE_MAKE_OPERATOR=4 val SCE_MAKE_TARGET=5 val SCE_MAKE_IDEOL=9 # Lexical states for SCLEX_DIFF lex Diff=SCLEX_DIFF SCE_DIFF_ val SCE_DIFF_DEFAULT=0 val SCE_DIFF_COMMENT=1 val SCE_DIFF_COMMAND=2 val SCE_DIFF_HEADER=3 val SCE_DIFF_POSITION=4 val SCE_DIFF_DELETED=5 val SCE_DIFF_ADDED=6 val SCE_DIFF_CHANGED=7 val SCE_DIFF_PATCH_ADD=8 val SCE_DIFF_PATCH_DELETE=9 val SCE_DIFF_REMOVED_PATCH_ADD=10 val SCE_DIFF_REMOVED_PATCH_DELETE=11 # Lexical states for SCLEX_CONF (Apache Configuration Files Lexer) lex Conf=SCLEX_CONF SCE_CONF_ val SCE_CONF_DEFAULT=0 val SCE_CONF_COMMENT=1 val SCE_CONF_NUMBER=2 val SCE_CONF_IDENTIFIER=3 val SCE_CONF_EXTENSION=4 val SCE_CONF_PARAMETER=5 val SCE_CONF_STRING=6 val SCE_CONF_OPERATOR=7 val SCE_CONF_IP=8 val SCE_CONF_DIRECTIVE=9 # Lexical states for SCLEX_AVE, Avenue lex Avenue=SCLEX_AVE SCE_AVE_ val SCE_AVE_DEFAULT=0 val SCE_AVE_COMMENT=1 val SCE_AVE_NUMBER=2 val SCE_AVE_WORD=3 val SCE_AVE_STRING=6 val SCE_AVE_ENUM=7 val SCE_AVE_STRINGEOL=8 val SCE_AVE_IDENTIFIER=9 val SCE_AVE_OPERATOR=10 val SCE_AVE_WORD1=11 val SCE_AVE_WORD2=12 val SCE_AVE_WORD3=13 val SCE_AVE_WORD4=14 val SCE_AVE_WORD5=15 val SCE_AVE_WORD6=16 # Lexical states for SCLEX_ADA lex Ada=SCLEX_ADA SCE_ADA_ val SCE_ADA_DEFAULT=0 val SCE_ADA_WORD=1 val SCE_ADA_IDENTIFIER=2 val SCE_ADA_NUMBER=3 val SCE_ADA_DELIMITER=4 val SCE_ADA_CHARACTER=5 val SCE_ADA_CHARACTEREOL=6 val SCE_ADA_STRING=7 val SCE_ADA_STRINGEOL=8 val SCE_ADA_LABEL=9 val SCE_ADA_COMMENTLINE=10 val SCE_ADA_ILLEGAL=11 # Lexical states for SCLEX_BAAN lex Baan=SCLEX_BAAN SCE_BAAN_ val SCE_BAAN_DEFAULT=0 val SCE_BAAN_COMMENT=1 val SCE_BAAN_COMMENTDOC=2 val SCE_BAAN_NUMBER=3 val SCE_BAAN_WORD=4 val SCE_BAAN_STRING=5 val SCE_BAAN_PREPROCESSOR=6 val SCE_BAAN_OPERATOR=7 val SCE_BAAN_IDENTIFIER=8 val SCE_BAAN_STRINGEOL=9 val SCE_BAAN_WORD2=10 val SCE_BAAN_WORD3=11 val SCE_BAAN_WORD4=12 val SCE_BAAN_WORD5=13 val SCE_BAAN_WORD6=14 val SCE_BAAN_WORD7=15 val SCE_BAAN_WORD8=16 val SCE_BAAN_WORD9=17 val SCE_BAAN_TABLEDEF=18 val SCE_BAAN_TABLESQL=19 val SCE_BAAN_FUNCTION=20 val SCE_BAAN_DOMDEF=21 val SCE_BAAN_FUNCDEF=22 val SCE_BAAN_OBJECTDEF=23 val SCE_BAAN_DEFINEDEF=24 # Lexical states for SCLEX_LISP lex Lisp=SCLEX_LISP SCE_LISP_ val SCE_LISP_DEFAULT=0 val SCE_LISP_COMMENT=1 val SCE_LISP_NUMBER=2 val SCE_LISP_KEYWORD=3 val SCE_LISP_KEYWORD_KW=4 val SCE_LISP_SYMBOL=5 val SCE_LISP_STRING=6 val SCE_LISP_STRINGEOL=8 val SCE_LISP_IDENTIFIER=9 val SCE_LISP_OPERATOR=10 val SCE_LISP_SPECIAL=11 val SCE_LISP_MULTI_COMMENT=12 # Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW lex Eiffel=SCLEX_EIFFEL SCE_EIFFEL_ lex EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_ val SCE_EIFFEL_DEFAULT=0 val SCE_EIFFEL_COMMENTLINE=1 val SCE_EIFFEL_NUMBER=2 val SCE_EIFFEL_WORD=3 val SCE_EIFFEL_STRING=4 val SCE_EIFFEL_CHARACTER=5 val SCE_EIFFEL_OPERATOR=6 val SCE_EIFFEL_IDENTIFIER=7 val SCE_EIFFEL_STRINGEOL=8 # Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer) lex NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_ val SCE_NNCRONTAB_DEFAULT=0 val SCE_NNCRONTAB_COMMENT=1 val SCE_NNCRONTAB_TASK=2 val SCE_NNCRONTAB_SECTION=3 val SCE_NNCRONTAB_KEYWORD=4 val SCE_NNCRONTAB_MODIFIER=5 val SCE_NNCRONTAB_ASTERISK=6 val SCE_NNCRONTAB_NUMBER=7 val SCE_NNCRONTAB_STRING=8 val SCE_NNCRONTAB_ENVIRONMENT=9 val SCE_NNCRONTAB_IDENTIFIER=10 # Lexical states for SCLEX_FORTH (Forth Lexer) lex Forth=SCLEX_FORTH SCE_FORTH_ val SCE_FORTH_DEFAULT=0 val SCE_FORTH_COMMENT=1 val SCE_FORTH_COMMENT_ML=2 val SCE_FORTH_IDENTIFIER=3 val SCE_FORTH_CONTROL=4 val SCE_FORTH_KEYWORD=5 val SCE_FORTH_DEFWORD=6 val SCE_FORTH_PREWORD1=7 val SCE_FORTH_PREWORD2=8 val SCE_FORTH_NUMBER=9 val SCE_FORTH_STRING=10 val SCE_FORTH_LOCALE=11 # Lexical states for SCLEX_MATLAB lex MatLab=SCLEX_MATLAB SCE_MATLAB_ val SCE_MATLAB_DEFAULT=0 val SCE_MATLAB_COMMENT=1 val SCE_MATLAB_COMMAND=2 val SCE_MATLAB_NUMBER=3 val SCE_MATLAB_KEYWORD=4 # single quoted string val SCE_MATLAB_STRING=5 val SCE_MATLAB_OPERATOR=6 val SCE_MATLAB_IDENTIFIER=7 val SCE_MATLAB_DOUBLEQUOTESTRING=8 # Lexical states for SCLEX_MAXIMA lex Maxima=SCLEX_MAXIMA SCE_MAXIMA_ val SCE_MAXIMA_OPERATOR=0 val SCE_MAXIMA_COMMANDENDING=1 val SCE_MAXIMA_COMMENT=2 val SCE_MAXIMA_NUMBER=3 val SCE_MAXIMA_STRING=4 val SCE_MAXIMA_COMMAND=5 val SCE_MAXIMA_VARIABLE=6 val SCE_MAXIMA_UNKNOWN=7 # Lexical states for SCLEX_SCRIPTOL lex Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_ val SCE_SCRIPTOL_DEFAULT=0 val SCE_SCRIPTOL_WHITE=1 val SCE_SCRIPTOL_COMMENTLINE=2 val SCE_SCRIPTOL_PERSISTENT=3 val SCE_SCRIPTOL_CSTYLE=4 val SCE_SCRIPTOL_COMMENTBLOCK=5 val SCE_SCRIPTOL_NUMBER=6 val SCE_SCRIPTOL_STRING=7 val SCE_SCRIPTOL_CHARACTER=8 val SCE_SCRIPTOL_STRINGEOL=9 val SCE_SCRIPTOL_KEYWORD=10 val SCE_SCRIPTOL_OPERATOR=11 val SCE_SCRIPTOL_IDENTIFIER=12 val SCE_SCRIPTOL_TRIPLE=13 val SCE_SCRIPTOL_CLASSNAME=14 val SCE_SCRIPTOL_PREPROCESSOR=15 # Lexical states for SCLEX_ASM, SCLEX_AS lex Asm=SCLEX_ASM SCE_ASM_ lex As=SCLEX_AS SCE_ASM_ val SCE_ASM_DEFAULT=0 val SCE_ASM_COMMENT=1 val SCE_ASM_NUMBER=2 val SCE_ASM_STRING=3 val SCE_ASM_OPERATOR=4 val SCE_ASM_IDENTIFIER=5 val SCE_ASM_CPUINSTRUCTION=6 val SCE_ASM_MATHINSTRUCTION=7 val SCE_ASM_REGISTER=8 val SCE_ASM_DIRECTIVE=9 val SCE_ASM_DIRECTIVEOPERAND=10 val SCE_ASM_COMMENTBLOCK=11 val SCE_ASM_CHARACTER=12 val SCE_ASM_STRINGEOL=13 val SCE_ASM_EXTINSTRUCTION=14 val SCE_ASM_COMMENTDIRECTIVE=15 # Lexical states for SCLEX_FORTRAN lex Fortran=SCLEX_FORTRAN SCE_F_ lex F77=SCLEX_F77 SCE_F_ val SCE_F_DEFAULT=0 val SCE_F_COMMENT=1 val SCE_F_NUMBER=2 val SCE_F_STRING1=3 val SCE_F_STRING2=4 val SCE_F_STRINGEOL=5 val SCE_F_OPERATOR=6 val SCE_F_IDENTIFIER=7 val SCE_F_WORD=8 val SCE_F_WORD2=9 val SCE_F_WORD3=10 val SCE_F_PREPROCESSOR=11 val SCE_F_OPERATOR2=12 val SCE_F_LABEL=13 val SCE_F_CONTINUATION=14 # Lexical states for SCLEX_CSS lex CSS=SCLEX_CSS SCE_CSS_ val SCE_CSS_DEFAULT=0 val SCE_CSS_TAG=1 val SCE_CSS_CLASS=2 val SCE_CSS_PSEUDOCLASS=3 val SCE_CSS_UNKNOWN_PSEUDOCLASS=4 val SCE_CSS_OPERATOR=5 val SCE_CSS_IDENTIFIER=6 val SCE_CSS_UNKNOWN_IDENTIFIER=7 val SCE_CSS_VALUE=8 val SCE_CSS_COMMENT=9 val SCE_CSS_ID=10 val SCE_CSS_IMPORTANT=11 val SCE_CSS_DIRECTIVE=12 val SCE_CSS_DOUBLESTRING=13 val SCE_CSS_SINGLESTRING=14 val SCE_CSS_IDENTIFIER2=15 val SCE_CSS_ATTRIBUTE=16 val SCE_CSS_IDENTIFIER3=17 val SCE_CSS_PSEUDOELEMENT=18 val SCE_CSS_EXTENDED_IDENTIFIER=19 val SCE_CSS_EXTENDED_PSEUDOCLASS=20 val SCE_CSS_EXTENDED_PSEUDOELEMENT=21 val SCE_CSS_GROUP_RULE=22 val SCE_CSS_VARIABLE=23 # Lexical states for SCLEX_POV lex POV=SCLEX_POV SCE_POV_ val SCE_POV_DEFAULT=0 val SCE_POV_COMMENT=1 val SCE_POV_COMMENTLINE=2 val SCE_POV_NUMBER=3 val SCE_POV_OPERATOR=4 val SCE_POV_IDENTIFIER=5 val SCE_POV_STRING=6 val SCE_POV_STRINGEOL=7 val SCE_POV_DIRECTIVE=8 val SCE_POV_BADDIRECTIVE=9 val SCE_POV_WORD2=10 val SCE_POV_WORD3=11 val SCE_POV_WORD4=12 val SCE_POV_WORD5=13 val SCE_POV_WORD6=14 val SCE_POV_WORD7=15 val SCE_POV_WORD8=16 # Lexical states for SCLEX_LOUT lex LOUT=SCLEX_LOUT SCE_LOUT_ val SCE_LOUT_DEFAULT=0 val SCE_LOUT_COMMENT=1 val SCE_LOUT_NUMBER=2 val SCE_LOUT_WORD=3 val SCE_LOUT_WORD2=4 val SCE_LOUT_WORD3=5 val SCE_LOUT_WORD4=6 val SCE_LOUT_STRING=7 val SCE_LOUT_OPERATOR=8 val SCE_LOUT_IDENTIFIER=9 val SCE_LOUT_STRINGEOL=10 # Lexical states for SCLEX_ESCRIPT lex ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_ val SCE_ESCRIPT_DEFAULT=0 val SCE_ESCRIPT_COMMENT=1 val SCE_ESCRIPT_COMMENTLINE=2 val SCE_ESCRIPT_COMMENTDOC=3 val SCE_ESCRIPT_NUMBER=4 val SCE_ESCRIPT_WORD=5 val SCE_ESCRIPT_STRING=6 val SCE_ESCRIPT_OPERATOR=7 val SCE_ESCRIPT_IDENTIFIER=8 val SCE_ESCRIPT_BRACE=9 val SCE_ESCRIPT_WORD2=10 val SCE_ESCRIPT_WORD3=11 # Lexical states for SCLEX_PS lex PS=SCLEX_PS SCE_PS_ val SCE_PS_DEFAULT=0 val SCE_PS_COMMENT=1 val SCE_PS_DSC_COMMENT=2 val SCE_PS_DSC_VALUE=3 val SCE_PS_NUMBER=4 val SCE_PS_NAME=5 val SCE_PS_KEYWORD=6 val SCE_PS_LITERAL=7 val SCE_PS_IMMEVAL=8 val SCE_PS_PAREN_ARRAY=9 val SCE_PS_PAREN_DICT=10 val SCE_PS_PAREN_PROC=11 val SCE_PS_TEXT=12 val SCE_PS_HEXSTRING=13 val SCE_PS_BASE85STRING=14 val SCE_PS_BADSTRINGCHAR=15 # Lexical states for SCLEX_NSIS lex NSIS=SCLEX_NSIS SCE_NSIS_ val SCE_NSIS_DEFAULT=0 val SCE_NSIS_COMMENT=1 val SCE_NSIS_STRINGDQ=2 val SCE_NSIS_STRINGLQ=3 val SCE_NSIS_STRINGRQ=4 val SCE_NSIS_FUNCTION=5 val SCE_NSIS_VARIABLE=6 val SCE_NSIS_LABEL=7 val SCE_NSIS_USERDEFINED=8 val SCE_NSIS_SECTIONDEF=9 val SCE_NSIS_SUBSECTIONDEF=10 val SCE_NSIS_IFDEFINEDEF=11 val SCE_NSIS_MACRODEF=12 val SCE_NSIS_STRINGVAR=13 val SCE_NSIS_NUMBER=14 val SCE_NSIS_SECTIONGROUP=15 val SCE_NSIS_PAGEEX=16 val SCE_NSIS_FUNCTIONDEF=17 val SCE_NSIS_COMMENTBOX=18 # Lexical states for SCLEX_MMIXAL lex MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_ val SCE_MMIXAL_LEADWS=0 val SCE_MMIXAL_COMMENT=1 val SCE_MMIXAL_LABEL=2 val SCE_MMIXAL_OPCODE=3 val SCE_MMIXAL_OPCODE_PRE=4 val SCE_MMIXAL_OPCODE_VALID=5 val SCE_MMIXAL_OPCODE_UNKNOWN=6 val SCE_MMIXAL_OPCODE_POST=7 val SCE_MMIXAL_OPERANDS=8 val SCE_MMIXAL_NUMBER=9 val SCE_MMIXAL_REF=10 val SCE_MMIXAL_CHAR=11 val SCE_MMIXAL_STRING=12 val SCE_MMIXAL_REGISTER=13 val SCE_MMIXAL_HEX=14 val SCE_MMIXAL_OPERATOR=15 val SCE_MMIXAL_SYMBOL=16 val SCE_MMIXAL_INCLUDE=17 # Lexical states for SCLEX_CLW lex Clarion=SCLEX_CLW SCE_CLW_ val SCE_CLW_DEFAULT=0 val SCE_CLW_LABEL=1 val SCE_CLW_COMMENT=2 val SCE_CLW_STRING=3 val SCE_CLW_USER_IDENTIFIER=4 val SCE_CLW_INTEGER_CONSTANT=5 val SCE_CLW_REAL_CONSTANT=6 val SCE_CLW_PICTURE_STRING=7 val SCE_CLW_KEYWORD=8 val SCE_CLW_COMPILER_DIRECTIVE=9 val SCE_CLW_RUNTIME_EXPRESSIONS=10 val SCE_CLW_BUILTIN_PROCEDURES_FUNCTION=11 val SCE_CLW_STRUCTURE_DATA_TYPE=12 val SCE_CLW_ATTRIBUTE=13 val SCE_CLW_STANDARD_EQUATE=14 val SCE_CLW_ERROR=15 val SCE_CLW_DEPRECATED=16 # Lexical states for SCLEX_LOT lex LOT=SCLEX_LOT SCE_LOT_ val SCE_LOT_DEFAULT=0 val SCE_LOT_HEADER=1 val SCE_LOT_BREAK=2 val SCE_LOT_SET=3 val SCE_LOT_PASS=4 val SCE_LOT_FAIL=5 val SCE_LOT_ABORT=6 # Lexical states for SCLEX_YAML lex YAML=SCLEX_YAML SCE_YAML_ val SCE_YAML_DEFAULT=0 val SCE_YAML_COMMENT=1 val SCE_YAML_IDENTIFIER=2 val SCE_YAML_KEYWORD=3 val SCE_YAML_NUMBER=4 val SCE_YAML_REFERENCE=5 val SCE_YAML_DOCUMENT=6 val SCE_YAML_TEXT=7 val SCE_YAML_ERROR=8 val SCE_YAML_OPERATOR=9 # Lexical states for SCLEX_TEX lex TeX=SCLEX_TEX SCE_TEX_ val SCE_TEX_DEFAULT=0 val SCE_TEX_SPECIAL=1 val SCE_TEX_GROUP=2 val SCE_TEX_SYMBOL=3 val SCE_TEX_COMMAND=4 val SCE_TEX_TEXT=5 lex Metapost=SCLEX_METAPOST SCE_METAPOST_ val SCE_METAPOST_DEFAULT=0 val SCE_METAPOST_SPECIAL=1 val SCE_METAPOST_GROUP=2 val SCE_METAPOST_SYMBOL=3 val SCE_METAPOST_COMMAND=4 val SCE_METAPOST_TEXT=5 val SCE_METAPOST_EXTRA=6 # Lexical states for SCLEX_ERLANG lex Erlang=SCLEX_ERLANG SCE_ERLANG_ val SCE_ERLANG_DEFAULT=0 val SCE_ERLANG_COMMENT=1 val SCE_ERLANG_VARIABLE=2 val SCE_ERLANG_NUMBER=3 val SCE_ERLANG_KEYWORD=4 val SCE_ERLANG_STRING=5 val SCE_ERLANG_OPERATOR=6 val SCE_ERLANG_ATOM=7 val SCE_ERLANG_FUNCTION_NAME=8 val SCE_ERLANG_CHARACTER=9 val SCE_ERLANG_MACRO=10 val SCE_ERLANG_RECORD=11 val SCE_ERLANG_PREPROC=12 val SCE_ERLANG_NODE_NAME=13 val SCE_ERLANG_COMMENT_FUNCTION=14 val SCE_ERLANG_COMMENT_MODULE=15 val SCE_ERLANG_COMMENT_DOC=16 val SCE_ERLANG_COMMENT_DOC_MACRO=17 val SCE_ERLANG_ATOM_QUOTED=18 val SCE_ERLANG_MACRO_QUOTED=19 val SCE_ERLANG_RECORD_QUOTED=20 val SCE_ERLANG_NODE_NAME_QUOTED=21 val SCE_ERLANG_BIFS=22 val SCE_ERLANG_MODULES=23 val SCE_ERLANG_MODULES_ATT=24 val SCE_ERLANG_UNKNOWN=31 # Lexical states for SCLEX_OCTAVE are identical to MatLab lex Octave=SCLEX_OCTAVE SCE_MATLAB_ # Lexical states for SCLEX_JULIA lex Julia=SCLEX_JULIA SCE_JULIA_ val SCE_JULIA_DEFAULT=0 val SCE_JULIA_COMMENT=1 val SCE_JULIA_NUMBER=2 val SCE_JULIA_KEYWORD1=3 val SCE_JULIA_KEYWORD2=4 val SCE_JULIA_KEYWORD3=5 val SCE_JULIA_CHAR=6 val SCE_JULIA_OPERATOR=7 val SCE_JULIA_BRACKET=8 val SCE_JULIA_IDENTIFIER=9 val SCE_JULIA_STRING=10 val SCE_JULIA_SYMBOL=11 val SCE_JULIA_MACRO=12 val SCE_JULIA_STRINGINTERP=13 val SCE_JULIA_DOCSTRING=14 val SCE_JULIA_STRINGLITERAL=15 val SCE_JULIA_COMMAND=16 val SCE_JULIA_COMMANDLITERAL=17 val SCE_JULIA_TYPEANNOT=18 val SCE_JULIA_LEXERROR=19 val SCE_JULIA_KEYWORD4=20 val SCE_JULIA_TYPEOPERATOR=21 # Lexical states for SCLEX_MSSQL lex MSSQL=SCLEX_MSSQL SCE_MSSQL_ val SCE_MSSQL_DEFAULT=0 val SCE_MSSQL_COMMENT=1 val SCE_MSSQL_LINE_COMMENT=2 val SCE_MSSQL_NUMBER=3 val SCE_MSSQL_STRING=4 val SCE_MSSQL_OPERATOR=5 val SCE_MSSQL_IDENTIFIER=6 val SCE_MSSQL_VARIABLE=7 val SCE_MSSQL_COLUMN_NAME=8 val SCE_MSSQL_STATEMENT=9 val SCE_MSSQL_DATATYPE=10 val SCE_MSSQL_SYSTABLE=11 val SCE_MSSQL_GLOBAL_VARIABLE=12 val SCE_MSSQL_FUNCTION=13 val SCE_MSSQL_STORED_PROCEDURE=14 val SCE_MSSQL_DEFAULT_PREF_DATATYPE=15 val SCE_MSSQL_COLUMN_NAME_2=16 # Lexical states for SCLEX_VERILOG lex Verilog=SCLEX_VERILOG SCE_V_ val SCE_V_DEFAULT=0 val SCE_V_COMMENT=1 val SCE_V_COMMENTLINE=2 val SCE_V_COMMENTLINEBANG=3 val SCE_V_NUMBER=4 val SCE_V_WORD=5 val SCE_V_STRING=6 val SCE_V_WORD2=7 val SCE_V_WORD3=8 val SCE_V_PREPROCESSOR=9 val SCE_V_OPERATOR=10 val SCE_V_IDENTIFIER=11 val SCE_V_STRINGEOL=12 val SCE_V_USER=19 val SCE_V_COMMENT_WORD=20 val SCE_V_INPUT=21 val SCE_V_OUTPUT=22 val SCE_V_INOUT=23 val SCE_V_PORT_CONNECT=24 # Lexical states for SCLEX_KIX lex Kix=SCLEX_KIX SCE_KIX_ val SCE_KIX_DEFAULT=0 val SCE_KIX_COMMENT=1 val SCE_KIX_STRING1=2 val SCE_KIX_STRING2=3 val SCE_KIX_NUMBER=4 val SCE_KIX_VAR=5 val SCE_KIX_MACRO=6 val SCE_KIX_KEYWORD=7 val SCE_KIX_FUNCTIONS=8 val SCE_KIX_OPERATOR=9 val SCE_KIX_COMMENTSTREAM=10 val SCE_KIX_IDENTIFIER=31 # Lexical states for SCLEX_GUI4CLI lex Gui4Cli=SCLEX_GUI4CLI SCE_GC_ val SCE_GC_DEFAULT=0 val SCE_GC_COMMENTLINE=1 val SCE_GC_COMMENTBLOCK=2 val SCE_GC_GLOBAL=3 val SCE_GC_EVENT=4 val SCE_GC_ATTRIBUTE=5 val SCE_GC_CONTROL=6 val SCE_GC_COMMAND=7 val SCE_GC_STRING=8 val SCE_GC_OPERATOR=9 # Lexical states for SCLEX_SPECMAN lex Specman=SCLEX_SPECMAN SCE_SN_ val SCE_SN_DEFAULT=0 val SCE_SN_CODE=1 val SCE_SN_COMMENTLINE=2 val SCE_SN_COMMENTLINEBANG=3 val SCE_SN_NUMBER=4 val SCE_SN_WORD=5 val SCE_SN_STRING=6 val SCE_SN_WORD2=7 val SCE_SN_WORD3=8 val SCE_SN_PREPROCESSOR=9 val SCE_SN_OPERATOR=10 val SCE_SN_IDENTIFIER=11 val SCE_SN_STRINGEOL=12 val SCE_SN_REGEXTAG=13 val SCE_SN_SIGNAL=14 val SCE_SN_USER=19 # Lexical states for SCLEX_AU3 lex Au3=SCLEX_AU3 SCE_AU3_ val SCE_AU3_DEFAULT=0 val SCE_AU3_COMMENT=1 val SCE_AU3_COMMENTBLOCK=2 val SCE_AU3_NUMBER=3 val SCE_AU3_FUNCTION=4 val SCE_AU3_KEYWORD=5 val SCE_AU3_MACRO=6 val SCE_AU3_STRING=7 val SCE_AU3_OPERATOR=8 val SCE_AU3_VARIABLE=9 val SCE_AU3_SENT=10 val SCE_AU3_PREPROCESSOR=11 val SCE_AU3_SPECIAL=12 val SCE_AU3_EXPAND=13 val SCE_AU3_COMOBJ=14 val SCE_AU3_UDF=15 # Lexical states for SCLEX_APDL lex APDL=SCLEX_APDL SCE_APDL_ val SCE_APDL_DEFAULT=0 val SCE_APDL_COMMENT=1 val SCE_APDL_COMMENTBLOCK=2 val SCE_APDL_NUMBER=3 val SCE_APDL_STRING=4 val SCE_APDL_OPERATOR=5 val SCE_APDL_WORD=6 val SCE_APDL_PROCESSOR=7 val SCE_APDL_COMMAND=8 val SCE_APDL_SLASHCOMMAND=9 val SCE_APDL_STARCOMMAND=10 val SCE_APDL_ARGUMENT=11 val SCE_APDL_FUNCTION=12 # Lexical states for SCLEX_BASH lex Bash=SCLEX_BASH SCE_SH_ val SCE_SH_DEFAULT=0 val SCE_SH_ERROR=1 val SCE_SH_COMMENTLINE=2 val SCE_SH_NUMBER=3 val SCE_SH_WORD=4 val SCE_SH_STRING=5 val SCE_SH_CHARACTER=6 val SCE_SH_OPERATOR=7 val SCE_SH_IDENTIFIER=8 val SCE_SH_SCALAR=9 val SCE_SH_PARAM=10 val SCE_SH_BACKTICKS=11 val SCE_SH_HERE_DELIM=12 val SCE_SH_HERE_Q=13 # Lexical states for SCLEX_ASN1 lex Asn1=SCLEX_ASN1 SCE_ASN1_ val SCE_ASN1_DEFAULT=0 val SCE_ASN1_COMMENT=1 val SCE_ASN1_IDENTIFIER=2 val SCE_ASN1_STRING=3 val SCE_ASN1_OID=4 val SCE_ASN1_SCALAR=5 val SCE_ASN1_KEYWORD=6 val SCE_ASN1_ATTRIBUTE=7 val SCE_ASN1_DESCRIPTOR=8 val SCE_ASN1_TYPE=9 val SCE_ASN1_OPERATOR=10 # Lexical states for SCLEX_VHDL lex VHDL=SCLEX_VHDL SCE_VHDL_ val SCE_VHDL_DEFAULT=0 val SCE_VHDL_COMMENT=1 val SCE_VHDL_COMMENTLINEBANG=2 val SCE_VHDL_NUMBER=3 val SCE_VHDL_STRING=4 val SCE_VHDL_OPERATOR=5 val SCE_VHDL_IDENTIFIER=6 val SCE_VHDL_STRINGEOL=7 val SCE_VHDL_KEYWORD=8 val SCE_VHDL_STDOPERATOR=9 val SCE_VHDL_ATTRIBUTE=10 val SCE_VHDL_STDFUNCTION=11 val SCE_VHDL_STDPACKAGE=12 val SCE_VHDL_STDTYPE=13 val SCE_VHDL_USERWORD=14 val SCE_VHDL_BLOCK_COMMENT=15 # Lexical states for SCLEX_CAML lex Caml=SCLEX_CAML SCE_CAML_ val SCE_CAML_DEFAULT=0 val SCE_CAML_IDENTIFIER=1 val SCE_CAML_TAGNAME=2 val SCE_CAML_KEYWORD=3 val SCE_CAML_KEYWORD2=4 val SCE_CAML_KEYWORD3=5 val SCE_CAML_LINENUM=6 val SCE_CAML_OPERATOR=7 val SCE_CAML_NUMBER=8 val SCE_CAML_CHAR=9 val SCE_CAML_WHITE=10 val SCE_CAML_STRING=11 val SCE_CAML_COMMENT=12 val SCE_CAML_COMMENT1=13 val SCE_CAML_COMMENT2=14 val SCE_CAML_COMMENT3=15 # Lexical states for SCLEX_HASKELL lex Haskell=SCLEX_HASKELL SCE_HA_ val SCE_HA_DEFAULT=0 val SCE_HA_IDENTIFIER=1 val SCE_HA_KEYWORD=2 val SCE_HA_NUMBER=3 val SCE_HA_STRING=4 val SCE_HA_CHARACTER=5 val SCE_HA_CLASS=6 val SCE_HA_MODULE=7 val SCE_HA_CAPITAL=8 val SCE_HA_DATA=9 val SCE_HA_IMPORT=10 val SCE_HA_OPERATOR=11 val SCE_HA_INSTANCE=12 val SCE_HA_COMMENTLINE=13 val SCE_HA_COMMENTBLOCK=14 val SCE_HA_COMMENTBLOCK2=15 val SCE_HA_COMMENTBLOCK3=16 val SCE_HA_PRAGMA=17 val SCE_HA_PREPROCESSOR=18 val SCE_HA_STRINGEOL=19 val SCE_HA_RESERVED_OPERATOR=20 val SCE_HA_LITERATE_COMMENT=21 val SCE_HA_LITERATE_CODEDELIM=22 # Lexical states of SCLEX_TADS3 lex TADS3=SCLEX_TADS3 SCE_T3_ val SCE_T3_DEFAULT=0 val SCE_T3_X_DEFAULT=1 val SCE_T3_PREPROCESSOR=2 val SCE_T3_BLOCK_COMMENT=3 val SCE_T3_LINE_COMMENT=4 val SCE_T3_OPERATOR=5 val SCE_T3_KEYWORD=6 val SCE_T3_NUMBER=7 val SCE_T3_IDENTIFIER=8 val SCE_T3_S_STRING=9 val SCE_T3_D_STRING=10 val SCE_T3_X_STRING=11 val SCE_T3_LIB_DIRECTIVE=12 val SCE_T3_MSG_PARAM=13 val SCE_T3_HTML_TAG=14 val SCE_T3_HTML_DEFAULT=15 val SCE_T3_HTML_STRING=16 val SCE_T3_USER1=17 val SCE_T3_USER2=18 val SCE_T3_USER3=19 val SCE_T3_BRACE=20 # Lexical states for SCLEX_REBOL lex Rebol=SCLEX_REBOL SCE_REBOL_ val SCE_REBOL_DEFAULT=0 val SCE_REBOL_COMMENTLINE=1 val SCE_REBOL_COMMENTBLOCK=2 val SCE_REBOL_PREFACE=3 val SCE_REBOL_OPERATOR=4 val SCE_REBOL_CHARACTER=5 val SCE_REBOL_QUOTEDSTRING=6 val SCE_REBOL_BRACEDSTRING=7 val SCE_REBOL_NUMBER=8 val SCE_REBOL_PAIR=9 val SCE_REBOL_TUPLE=10 val SCE_REBOL_BINARY=11 val SCE_REBOL_MONEY=12 val SCE_REBOL_ISSUE=13 val SCE_REBOL_TAG=14 val SCE_REBOL_FILE=15 val SCE_REBOL_EMAIL=16 val SCE_REBOL_URL=17 val SCE_REBOL_DATE=18 val SCE_REBOL_TIME=19 val SCE_REBOL_IDENTIFIER=20 val SCE_REBOL_WORD=21 val SCE_REBOL_WORD2=22 val SCE_REBOL_WORD3=23 val SCE_REBOL_WORD4=24 val SCE_REBOL_WORD5=25 val SCE_REBOL_WORD6=26 val SCE_REBOL_WORD7=27 val SCE_REBOL_WORD8=28 # Lexical states for SCLEX_SQL lex SQL=SCLEX_SQL SCE_SQL_ val SCE_SQL_DEFAULT=0 val SCE_SQL_COMMENT=1 val SCE_SQL_COMMENTLINE=2 val SCE_SQL_COMMENTDOC=3 val SCE_SQL_NUMBER=4 val SCE_SQL_WORD=5 val SCE_SQL_STRING=6 val SCE_SQL_CHARACTER=7 val SCE_SQL_SQLPLUS=8 val SCE_SQL_SQLPLUS_PROMPT=9 val SCE_SQL_OPERATOR=10 val SCE_SQL_IDENTIFIER=11 val SCE_SQL_SQLPLUS_COMMENT=13 val SCE_SQL_COMMENTLINEDOC=15 val SCE_SQL_WORD2=16 val SCE_SQL_COMMENTDOCKEYWORD=17 val SCE_SQL_COMMENTDOCKEYWORDERROR=18 val SCE_SQL_USER1=19 val SCE_SQL_USER2=20 val SCE_SQL_USER3=21 val SCE_SQL_USER4=22 val SCE_SQL_QUOTEDIDENTIFIER=23 val SCE_SQL_QOPERATOR=24 # Lexical states for SCLEX_SMALLTALK lex Smalltalk=SCLEX_SMALLTALK SCE_ST_ val SCE_ST_DEFAULT=0 val SCE_ST_STRING=1 val SCE_ST_NUMBER=2 val SCE_ST_COMMENT=3 val SCE_ST_SYMBOL=4 val SCE_ST_BINARY=5 val SCE_ST_BOOL=6 val SCE_ST_SELF=7 val SCE_ST_SUPER=8 val SCE_ST_NIL=9 val SCE_ST_GLOBAL=10 val SCE_ST_RETURN=11 val SCE_ST_SPECIAL=12 val SCE_ST_KWSEND=13 val SCE_ST_ASSIGN=14 val SCE_ST_CHARACTER=15 val SCE_ST_SPEC_SEL=16 # Lexical states for SCLEX_FLAGSHIP (clipper) lex FlagShip=SCLEX_FLAGSHIP SCE_FS_ val SCE_FS_DEFAULT=0 val SCE_FS_COMMENT=1 val SCE_FS_COMMENTLINE=2 val SCE_FS_COMMENTDOC=3 val SCE_FS_COMMENTLINEDOC=4 val SCE_FS_COMMENTDOCKEYWORD=5 val SCE_FS_COMMENTDOCKEYWORDERROR=6 val SCE_FS_KEYWORD=7 val SCE_FS_KEYWORD2=8 val SCE_FS_KEYWORD3=9 val SCE_FS_KEYWORD4=10 val SCE_FS_NUMBER=11 val SCE_FS_STRING=12 val SCE_FS_PREPROCESSOR=13 val SCE_FS_OPERATOR=14 val SCE_FS_IDENTIFIER=15 val SCE_FS_DATE=16 val SCE_FS_STRINGEOL=17 val SCE_FS_CONSTANT=18 val SCE_FS_WORDOPERATOR=19 val SCE_FS_DISABLEDCODE=20 val SCE_FS_DEFAULT_C=21 val SCE_FS_COMMENTDOC_C=22 val SCE_FS_COMMENTLINEDOC_C=23 val SCE_FS_KEYWORD_C=24 val SCE_FS_KEYWORD2_C=25 val SCE_FS_NUMBER_C=26 val SCE_FS_STRING_C=27 val SCE_FS_PREPROCESSOR_C=28 val SCE_FS_OPERATOR_C=29 val SCE_FS_IDENTIFIER_C=30 val SCE_FS_STRINGEOL_C=31 # Lexical states for SCLEX_CSOUND lex Csound=SCLEX_CSOUND SCE_CSOUND_ val SCE_CSOUND_DEFAULT=0 val SCE_CSOUND_COMMENT=1 val SCE_CSOUND_NUMBER=2 val SCE_CSOUND_OPERATOR=3 val SCE_CSOUND_INSTR=4 val SCE_CSOUND_IDENTIFIER=5 val SCE_CSOUND_OPCODE=6 val SCE_CSOUND_HEADERSTMT=7 val SCE_CSOUND_USERKEYWORD=8 val SCE_CSOUND_COMMENTBLOCK=9 val SCE_CSOUND_PARAM=10 val SCE_CSOUND_ARATE_VAR=11 val SCE_CSOUND_KRATE_VAR=12 val SCE_CSOUND_IRATE_VAR=13 val SCE_CSOUND_GLOBAL_VAR=14 val SCE_CSOUND_STRINGEOL=15 # Lexical states for SCLEX_INNOSETUP lex Inno=SCLEX_INNOSETUP SCE_INNO_ val SCE_INNO_DEFAULT=0 val SCE_INNO_COMMENT=1 val SCE_INNO_KEYWORD=2 val SCE_INNO_PARAMETER=3 val SCE_INNO_SECTION=4 val SCE_INNO_PREPROC=5 val SCE_INNO_INLINE_EXPANSION=6 val SCE_INNO_COMMENT_PASCAL=7 val SCE_INNO_KEYWORD_PASCAL=8 val SCE_INNO_KEYWORD_USER=9 val SCE_INNO_STRING_DOUBLE=10 val SCE_INNO_STRING_SINGLE=11 val SCE_INNO_IDENTIFIER=12 # Lexical states for SCLEX_OPAL lex Opal=SCLEX_OPAL SCE_OPAL_ val SCE_OPAL_SPACE=0 val SCE_OPAL_COMMENT_BLOCK=1 val SCE_OPAL_COMMENT_LINE=2 val SCE_OPAL_INTEGER=3 val SCE_OPAL_KEYWORD=4 val SCE_OPAL_SORT=5 val SCE_OPAL_STRING=6 val SCE_OPAL_PAR=7 val SCE_OPAL_BOOL_CONST=8 val SCE_OPAL_DEFAULT=32 # Lexical states for SCLEX_SPICE lex Spice=SCLEX_SPICE SCE_SPICE_ val SCE_SPICE_DEFAULT=0 val SCE_SPICE_IDENTIFIER=1 val SCE_SPICE_KEYWORD=2 val SCE_SPICE_KEYWORD2=3 val SCE_SPICE_KEYWORD3=4 val SCE_SPICE_NUMBER=5 val SCE_SPICE_DELIMITER=6 val SCE_SPICE_VALUE=7 val SCE_SPICE_COMMENTLINE=8 # Lexical states for SCLEX_CMAKE lex CMAKE=SCLEX_CMAKE SCE_CMAKE_ val SCE_CMAKE_DEFAULT=0 val SCE_CMAKE_COMMENT=1 val SCE_CMAKE_STRINGDQ=2 val SCE_CMAKE_STRINGLQ=3 val SCE_CMAKE_STRINGRQ=4 val SCE_CMAKE_COMMANDS=5 val SCE_CMAKE_PARAMETERS=6 val SCE_CMAKE_VARIABLE=7 val SCE_CMAKE_USERDEFINED=8 val SCE_CMAKE_WHILEDEF=9 val SCE_CMAKE_FOREACHDEF=10 val SCE_CMAKE_IFDEFINEDEF=11 val SCE_CMAKE_MACRODEF=12 val SCE_CMAKE_STRINGVAR=13 val SCE_CMAKE_NUMBER=14 # Lexical states for SCLEX_GAP lex Gap=SCLEX_GAP SCE_GAP_ val SCE_GAP_DEFAULT=0 val SCE_GAP_IDENTIFIER=1 val SCE_GAP_KEYWORD=2 val SCE_GAP_KEYWORD2=3 val SCE_GAP_KEYWORD3=4 val SCE_GAP_KEYWORD4=5 val SCE_GAP_STRING=6 val SCE_GAP_CHAR=7 val SCE_GAP_OPERATOR=8 val SCE_GAP_COMMENT=9 val SCE_GAP_NUMBER=10 val SCE_GAP_STRINGEOL=11 # Lexical state for SCLEX_PLM lex PLM=SCLEX_PLM SCE_PLM_ val SCE_PLM_DEFAULT=0 val SCE_PLM_COMMENT=1 val SCE_PLM_STRING=2 val SCE_PLM_NUMBER=3 val SCE_PLM_IDENTIFIER=4 val SCE_PLM_OPERATOR=5 val SCE_PLM_CONTROL=6 val SCE_PLM_KEYWORD=7 # Lexical state for SCLEX_PROGRESS lex Progress=SCLEX_PROGRESS SCE_ABL_ val SCE_ABL_DEFAULT=0 val SCE_ABL_NUMBER=1 val SCE_ABL_WORD=2 val SCE_ABL_STRING=3 val SCE_ABL_CHARACTER=4 val SCE_ABL_PREPROCESSOR=5 val SCE_ABL_OPERATOR=6 val SCE_ABL_IDENTIFIER=7 val SCE_ABL_BLOCK=8 val SCE_ABL_END=9 val SCE_ABL_COMMENT=10 val SCE_ABL_TASKMARKER=11 val SCE_ABL_LINECOMMENT=12 # Lexical states for SCLEX_ABAQUS lex ABAQUS=SCLEX_ABAQUS SCE_ABAQUS_ val SCE_ABAQUS_DEFAULT=0 val SCE_ABAQUS_COMMENT=1 val SCE_ABAQUS_COMMENTBLOCK=2 val SCE_ABAQUS_NUMBER=3 val SCE_ABAQUS_STRING=4 val SCE_ABAQUS_OPERATOR=5 val SCE_ABAQUS_WORD=6 val SCE_ABAQUS_PROCESSOR=7 val SCE_ABAQUS_COMMAND=8 val SCE_ABAQUS_SLASHCOMMAND=9 val SCE_ABAQUS_STARCOMMAND=10 val SCE_ABAQUS_ARGUMENT=11 val SCE_ABAQUS_FUNCTION=12 # Lexical states for SCLEX_ASYMPTOTE lex Asymptote=SCLEX_ASYMPTOTE SCE_ASY_ val SCE_ASY_DEFAULT=0 val SCE_ASY_COMMENT=1 val SCE_ASY_COMMENTLINE=2 val SCE_ASY_NUMBER=3 val SCE_ASY_WORD=4 val SCE_ASY_STRING=5 val SCE_ASY_CHARACTER=6 val SCE_ASY_OPERATOR=7 val SCE_ASY_IDENTIFIER=8 val SCE_ASY_STRINGEOL=9 val SCE_ASY_COMMENTLINEDOC=10 val SCE_ASY_WORD2=11 # Lexical states for SCLEX_R lex R=SCLEX_R SCE_R_ val SCE_R_DEFAULT=0 val SCE_R_COMMENT=1 val SCE_R_KWORD=2 val SCE_R_BASEKWORD=3 val SCE_R_OTHERKWORD=4 val SCE_R_NUMBER=5 val SCE_R_STRING=6 val SCE_R_STRING2=7 val SCE_R_OPERATOR=8 val SCE_R_IDENTIFIER=9 val SCE_R_INFIX=10 val SCE_R_INFIXEOL=11 val SCE_R_BACKTICKS=12 val SCE_R_RAWSTRING=13 val SCE_R_RAWSTRING2=14 val SCE_R_ESCAPESEQUENCE=15 # Lexical state for SCLEX_MAGIK lex MagikSF=SCLEX_MAGIK SCE_MAGIK_ val SCE_MAGIK_DEFAULT=0 val SCE_MAGIK_COMMENT=1 val SCE_MAGIK_HYPER_COMMENT=16 val SCE_MAGIK_STRING=2 val SCE_MAGIK_CHARACTER=3 val SCE_MAGIK_NUMBER=4 val SCE_MAGIK_IDENTIFIER=5 val SCE_MAGIK_OPERATOR=6 val SCE_MAGIK_FLOW=7 val SCE_MAGIK_CONTAINER=8 val SCE_MAGIK_BRACKET_BLOCK=9 val SCE_MAGIK_BRACE_BLOCK=10 val SCE_MAGIK_SQBRACKET_BLOCK=11 val SCE_MAGIK_UNKNOWN_KEYWORD=12 val SCE_MAGIK_KEYWORD=13 val SCE_MAGIK_PRAGMA=14 val SCE_MAGIK_SYMBOL=15 # Lexical state for SCLEX_POWERSHELL lex PowerShell=SCLEX_POWERSHELL SCE_POWERSHELL_ val SCE_POWERSHELL_DEFAULT=0 val SCE_POWERSHELL_COMMENT=1 val SCE_POWERSHELL_STRING=2 val SCE_POWERSHELL_CHARACTER=3 val SCE_POWERSHELL_NUMBER=4 val SCE_POWERSHELL_VARIABLE=5 val SCE_POWERSHELL_OPERATOR=6 val SCE_POWERSHELL_IDENTIFIER=7 val SCE_POWERSHELL_KEYWORD=8 val SCE_POWERSHELL_CMDLET=9 val SCE_POWERSHELL_ALIAS=10 val SCE_POWERSHELL_FUNCTION=11 val SCE_POWERSHELL_USER1=12 val SCE_POWERSHELL_COMMENTSTREAM=13 val SCE_POWERSHELL_HERE_STRING=14 val SCE_POWERSHELL_HERE_CHARACTER=15 val SCE_POWERSHELL_COMMENTDOCKEYWORD=16 # Lexical state for SCLEX_MYSQL lex MySQL=SCLEX_MYSQL SCE_MYSQL_ val SCE_MYSQL_DEFAULT=0 val SCE_MYSQL_COMMENT=1 val SCE_MYSQL_COMMENTLINE=2 val SCE_MYSQL_VARIABLE=3 val SCE_MYSQL_SYSTEMVARIABLE=4 val SCE_MYSQL_KNOWNSYSTEMVARIABLE=5 val SCE_MYSQL_NUMBER=6 val SCE_MYSQL_MAJORKEYWORD=7 val SCE_MYSQL_KEYWORD=8 val SCE_MYSQL_DATABASEOBJECT=9 val SCE_MYSQL_PROCEDUREKEYWORD=10 val SCE_MYSQL_STRING=11 val SCE_MYSQL_SQSTRING=12 val SCE_MYSQL_DQSTRING=13 val SCE_MYSQL_OPERATOR=14 val SCE_MYSQL_FUNCTION=15 val SCE_MYSQL_IDENTIFIER=16 val SCE_MYSQL_QUOTEDIDENTIFIER=17 val SCE_MYSQL_USER1=18 val SCE_MYSQL_USER2=19 val SCE_MYSQL_USER3=20 val SCE_MYSQL_HIDDENCOMMAND=21 val SCE_MYSQL_PLACEHOLDER=22 # Lexical state for SCLEX_PO lex Po=SCLEX_PO SCE_PO_ val SCE_PO_DEFAULT=0 val SCE_PO_COMMENT=1 val SCE_PO_MSGID=2 val SCE_PO_MSGID_TEXT=3 val SCE_PO_MSGSTR=4 val SCE_PO_MSGSTR_TEXT=5 val SCE_PO_MSGCTXT=6 val SCE_PO_MSGCTXT_TEXT=7 val SCE_PO_FUZZY=8 val SCE_PO_PROGRAMMER_COMMENT=9 val SCE_PO_REFERENCE=10 val SCE_PO_FLAGS=11 val SCE_PO_MSGID_TEXT_EOL=12 val SCE_PO_MSGSTR_TEXT_EOL=13 val SCE_PO_MSGCTXT_TEXT_EOL=14 val SCE_PO_ERROR=15 # Lexical states for SCLEX_PASCAL lex Pascal=SCLEX_PASCAL SCE_PAS_ val SCE_PAS_DEFAULT=0 val SCE_PAS_IDENTIFIER=1 val SCE_PAS_COMMENT=2 val SCE_PAS_COMMENT2=3 val SCE_PAS_COMMENTLINE=4 val SCE_PAS_PREPROCESSOR=5 val SCE_PAS_PREPROCESSOR2=6 val SCE_PAS_NUMBER=7 val SCE_PAS_HEXNUMBER=8 val SCE_PAS_WORD=9 val SCE_PAS_STRING=10 val SCE_PAS_STRINGEOL=11 val SCE_PAS_CHARACTER=12 val SCE_PAS_OPERATOR=13 val SCE_PAS_ASM=14 # Lexical state for SCLEX_SORCUS lex SORCUS=SCLEX_SORCUS SCE_SORCUS_ val SCE_SORCUS_DEFAULT=0 val SCE_SORCUS_COMMAND=1 val SCE_SORCUS_PARAMETER=2 val SCE_SORCUS_COMMENTLINE=3 val SCE_SORCUS_STRING=4 val SCE_SORCUS_STRINGEOL=5 val SCE_SORCUS_IDENTIFIER=6 val SCE_SORCUS_OPERATOR=7 val SCE_SORCUS_NUMBER=8 val SCE_SORCUS_CONSTANT=9 # Lexical state for SCLEX_POWERPRO lex PowerPro=SCLEX_POWERPRO SCE_POWERPRO_ val SCE_POWERPRO_DEFAULT=0 val SCE_POWERPRO_COMMENTBLOCK=1 val SCE_POWERPRO_COMMENTLINE=2 val SCE_POWERPRO_NUMBER=3 val SCE_POWERPRO_WORD=4 val SCE_POWERPRO_WORD2=5 val SCE_POWERPRO_WORD3=6 val SCE_POWERPRO_WORD4=7 val SCE_POWERPRO_DOUBLEQUOTEDSTRING=8 val SCE_POWERPRO_SINGLEQUOTEDSTRING=9 val SCE_POWERPRO_LINECONTINUE=10 val SCE_POWERPRO_OPERATOR=11 val SCE_POWERPRO_IDENTIFIER=12 val SCE_POWERPRO_STRINGEOL=13 val SCE_POWERPRO_VERBATIM=14 val SCE_POWERPRO_ALTQUOTE=15 val SCE_POWERPRO_FUNCTION=16 # Lexical states for SCLEX_SML lex SML=SCLEX_SML SCE_SML_ val SCE_SML_DEFAULT=0 val SCE_SML_IDENTIFIER=1 val SCE_SML_TAGNAME=2 val SCE_SML_KEYWORD=3 val SCE_SML_KEYWORD2=4 val SCE_SML_KEYWORD3=5 val SCE_SML_LINENUM=6 val SCE_SML_OPERATOR=7 val SCE_SML_NUMBER=8 val SCE_SML_CHAR=9 val SCE_SML_STRING=11 val SCE_SML_COMMENT=12 val SCE_SML_COMMENT1=13 val SCE_SML_COMMENT2=14 val SCE_SML_COMMENT3=15 # Lexical state for SCLEX_MARKDOWN lex Markdown=SCLEX_MARKDOWN SCE_MARKDOWN_ val SCE_MARKDOWN_DEFAULT=0 val SCE_MARKDOWN_LINE_BEGIN=1 val SCE_MARKDOWN_STRONG1=2 val SCE_MARKDOWN_STRONG2=3 val SCE_MARKDOWN_EM1=4 val SCE_MARKDOWN_EM2=5 val SCE_MARKDOWN_HEADER1=6 val SCE_MARKDOWN_HEADER2=7 val SCE_MARKDOWN_HEADER3=8 val SCE_MARKDOWN_HEADER4=9 val SCE_MARKDOWN_HEADER5=10 val SCE_MARKDOWN_HEADER6=11 val SCE_MARKDOWN_PRECHAR=12 val SCE_MARKDOWN_ULIST_ITEM=13 val SCE_MARKDOWN_OLIST_ITEM=14 val SCE_MARKDOWN_BLOCKQUOTE=15 val SCE_MARKDOWN_STRIKEOUT=16 val SCE_MARKDOWN_HRULE=17 val SCE_MARKDOWN_LINK=18 val SCE_MARKDOWN_CODE=19 val SCE_MARKDOWN_CODE2=20 val SCE_MARKDOWN_CODEBK=21 # Lexical state for SCLEX_TXT2TAGS lex Txt2tags=SCLEX_TXT2TAGS SCE_TXT2TAGS_ val SCE_TXT2TAGS_DEFAULT=0 val SCE_TXT2TAGS_LINE_BEGIN=1 val SCE_TXT2TAGS_STRONG1=2 val SCE_TXT2TAGS_STRONG2=3 val SCE_TXT2TAGS_EM1=4 val SCE_TXT2TAGS_EM2=5 val SCE_TXT2TAGS_HEADER1=6 val SCE_TXT2TAGS_HEADER2=7 val SCE_TXT2TAGS_HEADER3=8 val SCE_TXT2TAGS_HEADER4=9 val SCE_TXT2TAGS_HEADER5=10 val SCE_TXT2TAGS_HEADER6=11 val SCE_TXT2TAGS_PRECHAR=12 val SCE_TXT2TAGS_ULIST_ITEM=13 val SCE_TXT2TAGS_OLIST_ITEM=14 val SCE_TXT2TAGS_BLOCKQUOTE=15 val SCE_TXT2TAGS_STRIKEOUT=16 val SCE_TXT2TAGS_HRULE=17 val SCE_TXT2TAGS_LINK=18 val SCE_TXT2TAGS_CODE=19 val SCE_TXT2TAGS_CODE2=20 val SCE_TXT2TAGS_CODEBK=21 val SCE_TXT2TAGS_COMMENT=22 val SCE_TXT2TAGS_OPTION=23 val SCE_TXT2TAGS_PREPROC=24 val SCE_TXT2TAGS_POSTPROC=25 # Lexical states for SCLEX_A68K lex A68k=SCLEX_A68K SCE_A68K_ val SCE_A68K_DEFAULT=0 val SCE_A68K_COMMENT=1 val SCE_A68K_NUMBER_DEC=2 val SCE_A68K_NUMBER_BIN=3 val SCE_A68K_NUMBER_HEX=4 val SCE_A68K_STRING1=5 val SCE_A68K_OPERATOR=6 val SCE_A68K_CPUINSTRUCTION=7 val SCE_A68K_EXTINSTRUCTION=8 val SCE_A68K_REGISTER=9 val SCE_A68K_DIRECTIVE=10 val SCE_A68K_MACRO_ARG=11 val SCE_A68K_LABEL=12 val SCE_A68K_STRING2=13 val SCE_A68K_IDENTIFIER=14 val SCE_A68K_MACRO_DECLARATION=15 val SCE_A68K_COMMENT_WORD=16 val SCE_A68K_COMMENT_SPECIAL=17 val SCE_A68K_COMMENT_DOXYGEN=18 # Lexical states for SCLEX_MODULA lex Modula=SCLEX_MODULA SCE_MODULA_ val SCE_MODULA_DEFAULT=0 val SCE_MODULA_COMMENT=1 val SCE_MODULA_DOXYCOMM=2 val SCE_MODULA_DOXYKEY=3 val SCE_MODULA_KEYWORD=4 val SCE_MODULA_RESERVED=5 val SCE_MODULA_NUMBER=6 val SCE_MODULA_BASENUM=7 val SCE_MODULA_FLOAT=8 val SCE_MODULA_STRING=9 val SCE_MODULA_STRSPEC=10 val SCE_MODULA_CHAR=11 val SCE_MODULA_CHARSPEC=12 val SCE_MODULA_PROC=13 val SCE_MODULA_PRAGMA=14 val SCE_MODULA_PRGKEY=15 val SCE_MODULA_OPERATOR=16 val SCE_MODULA_BADSTR=17 # Lexical states for SCLEX_COFFEESCRIPT lex CoffeeScript=SCLEX_COFFEESCRIPT SCE_COFFEESCRIPT_ val SCE_COFFEESCRIPT_DEFAULT=0 val SCE_COFFEESCRIPT_COMMENT=1 val SCE_COFFEESCRIPT_COMMENTLINE=2 val SCE_COFFEESCRIPT_COMMENTDOC=3 val SCE_COFFEESCRIPT_NUMBER=4 val SCE_COFFEESCRIPT_WORD=5 val SCE_COFFEESCRIPT_STRING=6 val SCE_COFFEESCRIPT_CHARACTER=7 val SCE_COFFEESCRIPT_UUID=8 val SCE_COFFEESCRIPT_PREPROCESSOR=9 val SCE_COFFEESCRIPT_OPERATOR=10 val SCE_COFFEESCRIPT_IDENTIFIER=11 val SCE_COFFEESCRIPT_STRINGEOL=12 val SCE_COFFEESCRIPT_VERBATIM=13 val SCE_COFFEESCRIPT_REGEX=14 val SCE_COFFEESCRIPT_COMMENTLINEDOC=15 val SCE_COFFEESCRIPT_WORD2=16 val SCE_COFFEESCRIPT_COMMENTDOCKEYWORD=17 val SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR=18 val SCE_COFFEESCRIPT_GLOBALCLASS=19 val SCE_COFFEESCRIPT_STRINGRAW=20 val SCE_COFFEESCRIPT_TRIPLEVERBATIM=21 val SCE_COFFEESCRIPT_COMMENTBLOCK=22 val SCE_COFFEESCRIPT_VERBOSE_REGEX=23 val SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT=24 val SCE_COFFEESCRIPT_INSTANCEPROPERTY=25 # Lexical states for SCLEX_AVS lex AVS=SCLEX_AVS SCE_AVS_ val SCE_AVS_DEFAULT=0 val SCE_AVS_COMMENTBLOCK=1 val SCE_AVS_COMMENTBLOCKN=2 val SCE_AVS_COMMENTLINE=3 val SCE_AVS_NUMBER=4 val SCE_AVS_OPERATOR=5 val SCE_AVS_IDENTIFIER=6 val SCE_AVS_STRING=7 val SCE_AVS_TRIPLESTRING=8 val SCE_AVS_KEYWORD=9 val SCE_AVS_FILTER=10 val SCE_AVS_PLUGIN=11 val SCE_AVS_FUNCTION=12 val SCE_AVS_CLIPPROP=13 val SCE_AVS_USERDFN=14 # Lexical states for SCLEX_ECL lex ECL=SCLEX_ECL SCE_ECL_ val SCE_ECL_DEFAULT=0 val SCE_ECL_COMMENT=1 val SCE_ECL_COMMENTLINE=2 val SCE_ECL_NUMBER=3 val SCE_ECL_STRING=4 val SCE_ECL_WORD0=5 val SCE_ECL_OPERATOR=6 val SCE_ECL_CHARACTER=7 val SCE_ECL_UUID=8 val SCE_ECL_PREPROCESSOR=9 val SCE_ECL_UNKNOWN=10 val SCE_ECL_IDENTIFIER=11 val SCE_ECL_STRINGEOL=12 val SCE_ECL_VERBATIM=13 val SCE_ECL_REGEX=14 val SCE_ECL_COMMENTLINEDOC=15 val SCE_ECL_WORD1=16 val SCE_ECL_COMMENTDOCKEYWORD=17 val SCE_ECL_COMMENTDOCKEYWORDERROR=18 val SCE_ECL_WORD2=19 val SCE_ECL_WORD3=20 val SCE_ECL_WORD4=21 val SCE_ECL_WORD5=22 val SCE_ECL_COMMENTDOC=23 val SCE_ECL_ADDED=24 val SCE_ECL_DELETED=25 val SCE_ECL_CHANGED=26 val SCE_ECL_MOVED=27 # Lexical states for SCLEX_OSCRIPT lex OScript=SCLEX_OSCRIPT SCE_OSCRIPT_ val SCE_OSCRIPT_DEFAULT=0 val SCE_OSCRIPT_LINE_COMMENT=1 val SCE_OSCRIPT_BLOCK_COMMENT=2 val SCE_OSCRIPT_DOC_COMMENT=3 val SCE_OSCRIPT_PREPROCESSOR=4 val SCE_OSCRIPT_NUMBER=5 val SCE_OSCRIPT_SINGLEQUOTE_STRING=6 val SCE_OSCRIPT_DOUBLEQUOTE_STRING=7 val SCE_OSCRIPT_CONSTANT=8 val SCE_OSCRIPT_IDENTIFIER=9 val SCE_OSCRIPT_GLOBAL=10 val SCE_OSCRIPT_KEYWORD=11 val SCE_OSCRIPT_OPERATOR=12 val SCE_OSCRIPT_LABEL=13 val SCE_OSCRIPT_TYPE=14 val SCE_OSCRIPT_FUNCTION=15 val SCE_OSCRIPT_OBJECT=16 val SCE_OSCRIPT_PROPERTY=17 val SCE_OSCRIPT_METHOD=18 # Lexical states for SCLEX_VISUALPROLOG lex VisualProlog=SCLEX_VISUALPROLOG SCE_VISUALPROLOG_ val SCE_VISUALPROLOG_DEFAULT=0 val SCE_VISUALPROLOG_KEY_MAJOR=1 val SCE_VISUALPROLOG_KEY_MINOR=2 val SCE_VISUALPROLOG_KEY_DIRECTIVE=3 val SCE_VISUALPROLOG_COMMENT_BLOCK=4 val SCE_VISUALPROLOG_COMMENT_LINE=5 val SCE_VISUALPROLOG_COMMENT_KEY=6 val SCE_VISUALPROLOG_COMMENT_KEY_ERROR=7 val SCE_VISUALPROLOG_IDENTIFIER=8 val SCE_VISUALPROLOG_VARIABLE=9 val SCE_VISUALPROLOG_ANONYMOUS=10 val SCE_VISUALPROLOG_NUMBER=11 val SCE_VISUALPROLOG_OPERATOR=12 val SCE_VISUALPROLOG_UNUSED1=13 val SCE_VISUALPROLOG_UNUSED2=14 val SCE_VISUALPROLOG_UNUSED3=15 val SCE_VISUALPROLOG_STRING_QUOTE=16 val SCE_VISUALPROLOG_STRING_ESCAPE=17 val SCE_VISUALPROLOG_STRING_ESCAPE_ERROR=18 val SCE_VISUALPROLOG_UNUSED4=19 val SCE_VISUALPROLOG_STRING=20 val SCE_VISUALPROLOG_UNUSED5=21 val SCE_VISUALPROLOG_STRING_EOL=22 val SCE_VISUALPROLOG_EMBEDDED=23 val SCE_VISUALPROLOG_PLACEHOLDER=24 # Lexical states for SCLEX_STTXT lex StructuredText=SCLEX_STTXT SCE_STTXT_ val SCE_STTXT_DEFAULT=0 val SCE_STTXT_COMMENT=1 val SCE_STTXT_COMMENTLINE=2 val SCE_STTXT_KEYWORD=3 val SCE_STTXT_TYPE=4 val SCE_STTXT_FUNCTION=5 val SCE_STTXT_FB=6 val SCE_STTXT_NUMBER=7 val SCE_STTXT_HEXNUMBER=8 val SCE_STTXT_PRAGMA=9 val SCE_STTXT_OPERATOR=10 val SCE_STTXT_CHARACTER=11 val SCE_STTXT_STRING1=12 val SCE_STTXT_STRING2=13 val SCE_STTXT_STRINGEOL=14 val SCE_STTXT_IDENTIFIER=15 val SCE_STTXT_DATETIME=16 val SCE_STTXT_VARS=17 val SCE_STTXT_PRAGMAS=18 # Lexical states for SCLEX_KVIRC lex KVIrc=SCLEX_KVIRC SCE_KVIRC_ val SCE_KVIRC_DEFAULT=0 val SCE_KVIRC_COMMENT=1 val SCE_KVIRC_COMMENTBLOCK=2 val SCE_KVIRC_STRING=3 val SCE_KVIRC_WORD=4 val SCE_KVIRC_KEYWORD=5 val SCE_KVIRC_FUNCTION_KEYWORD=6 val SCE_KVIRC_FUNCTION=7 val SCE_KVIRC_VARIABLE=8 val SCE_KVIRC_NUMBER=9 val SCE_KVIRC_OPERATOR=10 val SCE_KVIRC_STRING_FUNCTION=11 val SCE_KVIRC_STRING_VARIABLE=12 # Lexical states for SCLEX_RUST lex Rust=SCLEX_RUST SCE_RUST_ val SCE_RUST_DEFAULT=0 val SCE_RUST_COMMENTBLOCK=1 val SCE_RUST_COMMENTLINE=2 val SCE_RUST_COMMENTBLOCKDOC=3 val SCE_RUST_COMMENTLINEDOC=4 val SCE_RUST_NUMBER=5 val SCE_RUST_WORD=6 val SCE_RUST_WORD2=7 val SCE_RUST_WORD3=8 val SCE_RUST_WORD4=9 val SCE_RUST_WORD5=10 val SCE_RUST_WORD6=11 val SCE_RUST_WORD7=12 val SCE_RUST_STRING=13 val SCE_RUST_STRINGR=14 val SCE_RUST_CHARACTER=15 val SCE_RUST_OPERATOR=16 val SCE_RUST_IDENTIFIER=17 val SCE_RUST_LIFETIME=18 val SCE_RUST_MACRO=19 val SCE_RUST_LEXERROR=20 val SCE_RUST_BYTESTRING=21 val SCE_RUST_BYTESTRINGR=22 val SCE_RUST_BYTECHARACTER=23 val SCE_RUST_CSTRING=24 val SCE_RUST_CSTRINGR=25 # Lexical states for SCLEX_DMAP lex DMAP=SCLEX_DMAP SCE_DMAP_ val SCE_DMAP_DEFAULT=0 val SCE_DMAP_COMMENT=1 val SCE_DMAP_NUMBER=2 val SCE_DMAP_STRING1=3 val SCE_DMAP_STRING2=4 val SCE_DMAP_STRINGEOL=5 val SCE_DMAP_OPERATOR=6 val SCE_DMAP_IDENTIFIER=7 val SCE_DMAP_WORD=8 val SCE_DMAP_WORD2=9 val SCE_DMAP_WORD3=10 # Lexical states for SCLEX_DMIS lex DMIS=SCLEX_DMIS SCE_DMIS_ val SCE_DMIS_DEFAULT=0 val SCE_DMIS_COMMENT=1 val SCE_DMIS_STRING=2 val SCE_DMIS_NUMBER=3 val SCE_DMIS_KEYWORD=4 val SCE_DMIS_MAJORWORD=5 val SCE_DMIS_MINORWORD=6 val SCE_DMIS_UNSUPPORTED_MAJOR=7 val SCE_DMIS_UNSUPPORTED_MINOR=8 val SCE_DMIS_LABEL=9 # Lexical states for SCLEX_REGISTRY lex REG=SCLEX_REGISTRY SCE_REG_ val SCE_REG_DEFAULT=0 val SCE_REG_COMMENT=1 val SCE_REG_VALUENAME=2 val SCE_REG_STRING=3 val SCE_REG_HEXDIGIT=4 val SCE_REG_VALUETYPE=5 val SCE_REG_ADDEDKEY=6 val SCE_REG_DELETEDKEY=7 val SCE_REG_ESCAPED=8 val SCE_REG_KEYPATH_GUID=9 val SCE_REG_STRING_GUID=10 val SCE_REG_PARAMETER=11 val SCE_REG_OPERATOR=12 # Lexical state for SCLEX_BIBTEX lex BibTeX=SCLEX_BIBTEX SCE_BIBTEX_ val SCE_BIBTEX_DEFAULT=0 val SCE_BIBTEX_ENTRY=1 val SCE_BIBTEX_UNKNOWN_ENTRY=2 val SCE_BIBTEX_KEY=3 val SCE_BIBTEX_PARAMETER=4 val SCE_BIBTEX_VALUE=5 val SCE_BIBTEX_COMMENT=6 # Lexical state for SCLEX_SREC lex Srec=SCLEX_SREC SCE_HEX_ val SCE_HEX_DEFAULT=0 val SCE_HEX_RECSTART=1 val SCE_HEX_RECTYPE=2 val SCE_HEX_RECTYPE_UNKNOWN=3 val SCE_HEX_BYTECOUNT=4 val SCE_HEX_BYTECOUNT_WRONG=5 val SCE_HEX_NOADDRESS=6 val SCE_HEX_DATAADDRESS=7 val SCE_HEX_RECCOUNT=8 val SCE_HEX_STARTADDRESS=9 val SCE_HEX_ADDRESSFIELD_UNKNOWN=10 val SCE_HEX_EXTENDEDADDRESS=11 val SCE_HEX_DATA_ODD=12 val SCE_HEX_DATA_EVEN=13 val SCE_HEX_DATA_UNKNOWN=14 val SCE_HEX_DATA_EMPTY=15 val SCE_HEX_CHECKSUM=16 val SCE_HEX_CHECKSUM_WRONG=17 val SCE_HEX_GARBAGE=18 # Lexical state for SCLEX_IHEX (shared with Srec) lex IHex=SCLEX_IHEX SCE_HEX_ # Lexical state for SCLEX_TEHEX (shared with Srec) lex TEHex=SCLEX_TEHEX SCE_HEX_ # Lexical states for SCLEX_JSON lex JSON=SCLEX_JSON SCE_JSON_ val SCE_JSON_DEFAULT=0 val SCE_JSON_NUMBER=1 val SCE_JSON_STRING=2 val SCE_JSON_STRINGEOL=3 val SCE_JSON_PROPERTYNAME=4 val SCE_JSON_ESCAPESEQUENCE=5 val SCE_JSON_LINECOMMENT=6 val SCE_JSON_BLOCKCOMMENT=7 val SCE_JSON_OPERATOR=8 val SCE_JSON_URI=9 val SCE_JSON_COMPACTIRI=10 val SCE_JSON_KEYWORD=11 val SCE_JSON_LDKEYWORD=12 val SCE_JSON_ERROR=13 lex EDIFACT=SCLEX_EDIFACT SCE_EDI_ val SCE_EDI_DEFAULT=0 val SCE_EDI_SEGMENTSTART=1 val SCE_EDI_SEGMENTEND=2 val SCE_EDI_SEP_ELEMENT=3 val SCE_EDI_SEP_COMPOSITE=4 val SCE_EDI_SEP_RELEASE=5 val SCE_EDI_UNA=6 val SCE_EDI_UNH=7 val SCE_EDI_BADSEGMENT=8 # Lexical states for SCLEX_STATA lex STATA=SCLEX_STATA SCE_STATA_ val SCE_STATA_DEFAULT=0 val SCE_STATA_COMMENT=1 val SCE_STATA_COMMENTLINE=2 val SCE_STATA_COMMENTBLOCK=3 val SCE_STATA_NUMBER=4 val SCE_STATA_OPERATOR=5 val SCE_STATA_IDENTIFIER=6 val SCE_STATA_STRING=7 val SCE_STATA_TYPE=8 val SCE_STATA_WORD=9 val SCE_STATA_GLOBAL_MACRO=10 val SCE_STATA_MACRO=11 # Lexical states for SCLEX_SAS lex SAS=SCLEX_SAS SCE_SAS_ val SCE_SAS_DEFAULT=0 val SCE_SAS_COMMENT=1 val SCE_SAS_COMMENTLINE=2 val SCE_SAS_COMMENTBLOCK=3 val SCE_SAS_NUMBER=4 val SCE_SAS_OPERATOR=5 val SCE_SAS_IDENTIFIER=6 val SCE_SAS_STRING=7 val SCE_SAS_TYPE=8 val SCE_SAS_WORD=9 val SCE_SAS_GLOBAL_MACRO=10 val SCE_SAS_MACRO=11 val SCE_SAS_MACRO_KEYWORD=12 val SCE_SAS_BLOCK_KEYWORD=13 val SCE_SAS_MACRO_FUNCTION=14 val SCE_SAS_STATEMENT=15 # Lexical states for SCLEX_NIM lex Nim=SCLEX_NIM SCE_NIM_ val SCE_NIM_DEFAULT=0 val SCE_NIM_COMMENT=1 val SCE_NIM_COMMENTDOC=2 val SCE_NIM_COMMENTLINE=3 val SCE_NIM_COMMENTLINEDOC=4 val SCE_NIM_NUMBER=5 val SCE_NIM_STRING=6 val SCE_NIM_CHARACTER=7 val SCE_NIM_WORD=8 val SCE_NIM_TRIPLE=9 val SCE_NIM_TRIPLEDOUBLE=10 val SCE_NIM_BACKTICKS=11 val SCE_NIM_FUNCNAME=12 val SCE_NIM_STRINGEOL=13 val SCE_NIM_NUMERROR=14 val SCE_NIM_OPERATOR=15 val SCE_NIM_IDENTIFIER=16 # Lexical states for SCLEX_CIL lex CIL=SCLEX_CIL SCE_CIL_ val SCE_CIL_DEFAULT=0 val SCE_CIL_COMMENT=1 val SCE_CIL_COMMENTLINE=2 val SCE_CIL_WORD=3 val SCE_CIL_WORD2=4 val SCE_CIL_WORD3=5 val SCE_CIL_STRING=6 val SCE_CIL_LABEL=7 val SCE_CIL_OPERATOR=8 val SCE_CIL_IDENTIFIER=9 val SCE_CIL_STRINGEOL=10 # Lexical states for SCLEX_X12 lex X12=SCLEX_X12 SCE_X12_ val SCE_X12_DEFAULT=0 val SCE_X12_BAD=1 val SCE_X12_ENVELOPE=2 val SCE_X12_FUNCTIONGROUP=3 val SCE_X12_TRANSACTIONSET=4 val SCE_X12_SEGMENTHEADER=5 val SCE_X12_SEGMENTEND=6 val SCE_X12_SEP_ELEMENT=7 val SCE_X12_SEP_SUBELEMENT=8 # Lexical states for SCLEX_DATAFLEX lex Dataflex=SCLEX_DATAFLEX SCE_DF_ val SCE_DF_DEFAULT=0 val SCE_DF_IDENTIFIER=1 val SCE_DF_METATAG=2 val SCE_DF_IMAGE=3 val SCE_DF_COMMENTLINE=4 val SCE_DF_PREPROCESSOR=5 val SCE_DF_PREPROCESSOR2=6 val SCE_DF_NUMBER=7 val SCE_DF_HEXNUMBER=8 val SCE_DF_WORD=9 val SCE_DF_STRING=10 val SCE_DF_STRINGEOL=11 val SCE_DF_SCOPEWORD=12 val SCE_DF_OPERATOR=13 val SCE_DF_ICODE=14 # Lexical states for SCLEX_HOLLYWOOD lex Hollywood=SCLEX_HOLLYWOOD SCE_HOLLYWOOD_ val SCE_HOLLYWOOD_DEFAULT=0 val SCE_HOLLYWOOD_COMMENT=1 val SCE_HOLLYWOOD_COMMENTBLOCK=2 val SCE_HOLLYWOOD_NUMBER=3 val SCE_HOLLYWOOD_KEYWORD=4 val SCE_HOLLYWOOD_STDAPI=5 val SCE_HOLLYWOOD_PLUGINAPI=6 val SCE_HOLLYWOOD_PLUGINMETHOD=7 val SCE_HOLLYWOOD_STRING=8 val SCE_HOLLYWOOD_STRINGBLOCK=9 val SCE_HOLLYWOOD_PREPROCESSOR=10 val SCE_HOLLYWOOD_OPERATOR=11 val SCE_HOLLYWOOD_IDENTIFIER=12 val SCE_HOLLYWOOD_CONSTANT=13 val SCE_HOLLYWOOD_HEXNUMBER=14 # Lexical states for SCLEX_RAKU lex Raku=SCLEX_RAKU SCE_RAKU_ val SCE_RAKU_DEFAULT=0 val SCE_RAKU_ERROR=1 val SCE_RAKU_COMMENTLINE=2 val SCE_RAKU_COMMENTEMBED=3 val SCE_RAKU_POD=4 val SCE_RAKU_CHARACTER=5 val SCE_RAKU_HEREDOC_Q=6 val SCE_RAKU_HEREDOC_QQ=7 val SCE_RAKU_STRING=8 val SCE_RAKU_STRING_Q=9 val SCE_RAKU_STRING_QQ=10 val SCE_RAKU_STRING_Q_LANG=11 val SCE_RAKU_STRING_VAR=12 val SCE_RAKU_REGEX=13 val SCE_RAKU_REGEX_VAR=14 val SCE_RAKU_ADVERB=15 val SCE_RAKU_NUMBER=16 val SCE_RAKU_PREPROCESSOR=17 val SCE_RAKU_OPERATOR=18 val SCE_RAKU_WORD=19 val SCE_RAKU_FUNCTION=20 val SCE_RAKU_IDENTIFIER=21 val SCE_RAKU_TYPEDEF=22 val SCE_RAKU_MU=23 val SCE_RAKU_POSITIONAL=24 val SCE_RAKU_ASSOCIATIVE=25 val SCE_RAKU_CALLABLE=26 val SCE_RAKU_GRAMMAR=27 val SCE_RAKU_CLASS=28 # Lexical states for SCLEX_FSHARP lex FSharp=SCLEX_FSHARP SCE_FSHARP_ val SCE_FSHARP_DEFAULT=0 val SCE_FSHARP_KEYWORD=1 val SCE_FSHARP_KEYWORD2=2 val SCE_FSHARP_KEYWORD3=3 val SCE_FSHARP_KEYWORD4=4 val SCE_FSHARP_KEYWORD5=5 val SCE_FSHARP_IDENTIFIER=6 val SCE_FSHARP_QUOT_IDENTIFIER=7 val SCE_FSHARP_COMMENT=8 val SCE_FSHARP_COMMENTLINE=9 val SCE_FSHARP_PREPROCESSOR=10 val SCE_FSHARP_LINENUM=11 val SCE_FSHARP_OPERATOR=12 val SCE_FSHARP_NUMBER=13 val SCE_FSHARP_CHARACTER=14 val SCE_FSHARP_STRING=15 val SCE_FSHARP_VERBATIM=16 val SCE_FSHARP_QUOTATION=17 val SCE_FSHARP_ATTRIBUTE=18 val SCE_FSHARP_FORMAT_SPEC=19 # Lexical states for SCLEX_ASCIIDOC lex Asciidoc=SCLEX_ASCIIDOC SCE_ASCIIDOC_ val SCE_ASCIIDOC_DEFAULT=0 val SCE_ASCIIDOC_STRONG1=1 val SCE_ASCIIDOC_STRONG2=2 val SCE_ASCIIDOC_EM1=3 val SCE_ASCIIDOC_EM2=4 val SCE_ASCIIDOC_HEADER1=5 val SCE_ASCIIDOC_HEADER2=6 val SCE_ASCIIDOC_HEADER3=7 val SCE_ASCIIDOC_HEADER4=8 val SCE_ASCIIDOC_HEADER5=9 val SCE_ASCIIDOC_HEADER6=10 val SCE_ASCIIDOC_ULIST_ITEM=11 val SCE_ASCIIDOC_OLIST_ITEM=12 val SCE_ASCIIDOC_BLOCKQUOTE=13 val SCE_ASCIIDOC_LINK=14 val SCE_ASCIIDOC_CODEBK=15 val SCE_ASCIIDOC_PASSBK=16 val SCE_ASCIIDOC_COMMENT=17 val SCE_ASCIIDOC_COMMENTBK=18 val SCE_ASCIIDOC_LITERAL=19 val SCE_ASCIIDOC_LITERALBK=20 val SCE_ASCIIDOC_ATTRIB=21 val SCE_ASCIIDOC_ATTRIBVAL=22 val SCE_ASCIIDOC_MACRO=23 # Lexical states for SCLEX_GDSCRIPT lex GDScript=SCLEX_GDSCRIPT SCE_GD_ val SCE_GD_DEFAULT=0 val SCE_GD_COMMENTLINE=1 val SCE_GD_NUMBER=2 val SCE_GD_STRING=3 val SCE_GD_CHARACTER=4 val SCE_GD_WORD=5 val SCE_GD_TRIPLE=6 val SCE_GD_TRIPLEDOUBLE=7 val SCE_GD_CLASSNAME=8 val SCE_GD_FUNCNAME=9 val SCE_GD_OPERATOR=10 val SCE_GD_IDENTIFIER=11 val SCE_GD_COMMENTBLOCK=12 val SCE_GD_STRINGEOL=13 val SCE_GD_WORD2=14 val SCE_GD_ANNOTATION=15 val SCE_GD_NODEPATH=16 # Lexical states for SCLEX_TOML lex TOML=SCLEX_TOML SCE_TOML_ val SCE_TOML_DEFAULT=0 val SCE_TOML_COMMENT=1 val SCE_TOML_IDENTIFIER=2 val SCE_TOML_KEYWORD=3 val SCE_TOML_NUMBER=4 val SCE_TOML_TABLE=5 val SCE_TOML_KEY=6 val SCE_TOML_ERROR=7 val SCE_TOML_OPERATOR=8 val SCE_TOML_STRING_SQ=9 val SCE_TOML_STRING_DQ=10 val SCE_TOML_TRIPLE_STRING_SQ=11 val SCE_TOML_TRIPLE_STRING_DQ=12 val SCE_TOML_ESCAPECHAR=13 val SCE_TOML_DATETIME=14 # Lexical states for SCLEX_TROFF lex troff=SCLEX_TROFF SCE_TROFF_ val SCE_TROFF_DEFAULT=0 val SCE_TROFF_REQUEST=1 val SCE_TROFF_COMMAND=2 val SCE_TROFF_NUMBER=3 val SCE_TROFF_OPERATOR=4 val SCE_TROFF_STRING=5 val SCE_TROFF_COMMENT=6 val SCE_TROFF_IGNORE=7 val SCE_TROFF_ESCAPE_STRING=8 val SCE_TROFF_ESCAPE_MACRO=9 val SCE_TROFF_ESCAPE_FONT=10 val SCE_TROFF_ESCAPE_NUMBER=11 val SCE_TROFF_ESCAPE_COLOUR=12 val SCE_TROFF_ESCAPE_GLYPH=13 val SCE_TROFF_ESCAPE_ENV=14 val SCE_TROFF_ESCAPE_SUPPRESSION=15 val SCE_TROFF_ESCAPE_SIZE=16 val SCE_TROFF_ESCAPE_TRANSPARENT=17 val SCE_TROFF_ESCAPE_ISVALID=18 val SCE_TROFF_ESCAPE_DRAW=19 val SCE_TROFF_ESCAPE_MOVE=20 val SCE_TROFF_ESCAPE_HEIGHT=21 val SCE_TROFF_ESCAPE_OVERSTRIKE=22 val SCE_TROFF_ESCAPE_SLANT=23 val SCE_TROFF_ESCAPE_WIDTH=24 val SCE_TROFF_ESCAPE_VSPACING=25 val SCE_TROFF_ESCAPE_DEVICE=26 val SCE_TROFF_ESCAPE_NOMOVE=27 # Lexical states for SCLEX_DART lex Dart=SCLEX_DART SCE_DART_ val SCE_DART_DEFAULT=0 val SCE_DART_COMMENTLINE=1 val SCE_DART_COMMENTLINEDOC=2 val SCE_DART_COMMENTBLOCK=3 val SCE_DART_COMMENTBLOCKDOC=4 val SCE_DART_STRING_SQ=5 val SCE_DART_STRING_DQ=6 val SCE_DART_TRIPLE_STRING_SQ=7 val SCE_DART_TRIPLE_STRING_DQ=8 val SCE_DART_RAWSTRING_SQ=9 val SCE_DART_RAWSTRING_DQ=10 val SCE_DART_TRIPLE_RAWSTRING_SQ=11 val SCE_DART_TRIPLE_RAWSTRING_DQ=12 val SCE_DART_ESCAPECHAR=13 val SCE_DART_IDENTIFIER=14 val SCE_DART_IDENTIFIER_STRING=15 val SCE_DART_OPERATOR=16 val SCE_DART_OPERATOR_STRING=17 val SCE_DART_SYMBOL_IDENTIFIER=18 val SCE_DART_SYMBOL_OPERATOR=19 val SCE_DART_NUMBER=20 val SCE_DART_KEY=21 val SCE_DART_METADATA=22 val SCE_DART_KW_PRIMARY=23 val SCE_DART_KW_SECONDARY=24 val SCE_DART_KW_TERTIARY=25 val SCE_DART_KW_TYPE=26 # Lexical states for SCLEX_ZIG lex Zig=SCLEX_ZIG SCE_ZIG_ val SCE_ZIG_DEFAULT=0 val SCE_ZIG_COMMENTLINE=1 val SCE_ZIG_COMMENTLINEDOC=2 val SCE_ZIG_COMMENTLINETOP=3 val SCE_ZIG_NUMBER=4 val SCE_ZIG_OPERATOR=5 val SCE_ZIG_CHARACTER=6 val SCE_ZIG_STRING=7 val SCE_ZIG_MULTISTRING=8 val SCE_ZIG_ESCAPECHAR=9 val SCE_ZIG_IDENTIFIER=10 val SCE_ZIG_FUNCTION=11 val SCE_ZIG_BUILTIN_FUNCTION=12 val SCE_ZIG_KW_PRIMARY=13 val SCE_ZIG_KW_SECONDARY=14 val SCE_ZIG_KW_TERTIARY=15 val SCE_ZIG_KW_TYPE=16 val SCE_ZIG_IDENTIFIER_STRING=17 # Lexical states for SCLEX_NIX lex Nix=SCLEX_NIX SCE_NIX_ val SCE_NIX_DEFAULT=0 val SCE_NIX_COMMENTLINE=1 val SCE_NIX_COMMENTBLOCK=2 val SCE_NIX_STRING=3 val SCE_NIX_STRING_MULTILINE=4 val SCE_NIX_ESCAPECHAR=5 val SCE_NIX_IDENTIFIER=6 val SCE_NIX_OPERATOR=7 val SCE_NIX_OPERATOR_STRING=8 val SCE_NIX_NUMBER=9 val SCE_NIX_KEY=10 val SCE_NIX_PATH=11 val SCE_NIX_KEYWORD1=12 val SCE_NIX_KEYWORD2=13 val SCE_NIX_KEYWORD3=14 val SCE_NIX_KEYWORD4=15 tmpok_q575y/lexilla/include/SciLexer.h0000664000175000017500000017225414773064066017530 0ustar gusnangusnan/* Scintilla source code edit control */ /** @file SciLexer.h ** Interface to the added lexer functions in the SciLexer version of the edit control. **/ /* Copyright 1998-2002 by Neil Hodgson * The License.txt file describes the conditions under which this software may be distributed. */ /* Most of this file is automatically generated from the Scintilla.iface interface definition * file which contains any comments about the definitions. HFacer.py does the generation. */ #ifndef SCILEXER_H #define SCILEXER_H /* SciLexer features - not in standard Scintilla */ /* ++Autogenerated -- start of section automatically generated from Scintilla.iface */ #define SCLEX_CONTAINER 0 #define SCLEX_NULL 1 #define SCLEX_PYTHON 2 #define SCLEX_CPP 3 #define SCLEX_HTML 4 #define SCLEX_XML 5 #define SCLEX_PERL 6 #define SCLEX_SQL 7 #define SCLEX_VB 8 #define SCLEX_PROPERTIES 9 #define SCLEX_ERRORLIST 10 #define SCLEX_MAKEFILE 11 #define SCLEX_BATCH 12 #define SCLEX_XCODE 13 #define SCLEX_LATEX 14 #define SCLEX_LUA 15 #define SCLEX_DIFF 16 #define SCLEX_CONF 17 #define SCLEX_PASCAL 18 #define SCLEX_AVE 19 #define SCLEX_ADA 20 #define SCLEX_LISP 21 #define SCLEX_RUBY 22 #define SCLEX_EIFFEL 23 #define SCLEX_EIFFELKW 24 #define SCLEX_TCL 25 #define SCLEX_NNCRONTAB 26 #define SCLEX_BULLANT 27 #define SCLEX_VBSCRIPT 28 #define SCLEX_BAAN 31 #define SCLEX_MATLAB 32 #define SCLEX_SCRIPTOL 33 #define SCLEX_ASM 34 #define SCLEX_CPPNOCASE 35 #define SCLEX_FORTRAN 36 #define SCLEX_F77 37 #define SCLEX_CSS 38 #define SCLEX_POV 39 #define SCLEX_LOUT 40 #define SCLEX_ESCRIPT 41 #define SCLEX_PS 42 #define SCLEX_NSIS 43 #define SCLEX_MMIXAL 44 #define SCLEX_CLW 45 #define SCLEX_CLWNOCASE 46 #define SCLEX_LOT 47 #define SCLEX_YAML 48 #define SCLEX_TEX 49 #define SCLEX_METAPOST 50 #define SCLEX_POWERBASIC 51 #define SCLEX_FORTH 52 #define SCLEX_ERLANG 53 #define SCLEX_OCTAVE 54 #define SCLEX_MSSQL 55 #define SCLEX_VERILOG 56 #define SCLEX_KIX 57 #define SCLEX_GUI4CLI 58 #define SCLEX_SPECMAN 59 #define SCLEX_AU3 60 #define SCLEX_APDL 61 #define SCLEX_BASH 62 #define SCLEX_ASN1 63 #define SCLEX_VHDL 64 #define SCLEX_CAML 65 #define SCLEX_BLITZBASIC 66 #define SCLEX_PUREBASIC 67 #define SCLEX_HASKELL 68 #define SCLEX_PHPSCRIPT 69 #define SCLEX_TADS3 70 #define SCLEX_REBOL 71 #define SCLEX_SMALLTALK 72 #define SCLEX_FLAGSHIP 73 #define SCLEX_CSOUND 74 #define SCLEX_FREEBASIC 75 #define SCLEX_INNOSETUP 76 #define SCLEX_OPAL 77 #define SCLEX_SPICE 78 #define SCLEX_D 79 #define SCLEX_CMAKE 80 #define SCLEX_GAP 81 #define SCLEX_PLM 82 #define SCLEX_PROGRESS 83 #define SCLEX_ABAQUS 84 #define SCLEX_ASYMPTOTE 85 #define SCLEX_R 86 #define SCLEX_MAGIK 87 #define SCLEX_POWERSHELL 88 #define SCLEX_MYSQL 89 #define SCLEX_PO 90 #define SCLEX_TAL 91 #define SCLEX_COBOL 92 #define SCLEX_TACL 93 #define SCLEX_SORCUS 94 #define SCLEX_POWERPRO 95 #define SCLEX_NIMROD 96 #define SCLEX_SML 97 #define SCLEX_MARKDOWN 98 #define SCLEX_TXT2TAGS 99 #define SCLEX_A68K 100 #define SCLEX_MODULA 101 #define SCLEX_COFFEESCRIPT 102 #define SCLEX_TCMD 103 #define SCLEX_AVS 104 #define SCLEX_ECL 105 #define SCLEX_OSCRIPT 106 #define SCLEX_VISUALPROLOG 107 #define SCLEX_LITERATEHASKELL 108 #define SCLEX_STTXT 109 #define SCLEX_KVIRC 110 #define SCLEX_RUST 111 #define SCLEX_DMAP 112 #define SCLEX_AS 113 #define SCLEX_DMIS 114 #define SCLEX_REGISTRY 115 #define SCLEX_BIBTEX 116 #define SCLEX_SREC 117 #define SCLEX_IHEX 118 #define SCLEX_TEHEX 119 #define SCLEX_JSON 120 #define SCLEX_EDIFACT 121 #define SCLEX_INDENT 122 #define SCLEX_MAXIMA 123 #define SCLEX_STATA 124 #define SCLEX_SAS 125 #define SCLEX_NIM 126 #define SCLEX_CIL 127 #define SCLEX_X12 128 #define SCLEX_DATAFLEX 129 #define SCLEX_HOLLYWOOD 130 #define SCLEX_RAKU 131 #define SCLEX_FSHARP 132 #define SCLEX_JULIA 133 #define SCLEX_ASCIIDOC 134 #define SCLEX_GDSCRIPT 135 #define SCLEX_TOML 136 #define SCLEX_TROFF 137 #define SCLEX_DART 138 #define SCLEX_ZIG 139 #define SCLEX_NIX 140 #define SCLEX_AUTOMATIC 1000 #define SCE_P_DEFAULT 0 #define SCE_P_COMMENTLINE 1 #define SCE_P_NUMBER 2 #define SCE_P_STRING 3 #define SCE_P_CHARACTER 4 #define SCE_P_WORD 5 #define SCE_P_TRIPLE 6 #define SCE_P_TRIPLEDOUBLE 7 #define SCE_P_CLASSNAME 8 #define SCE_P_DEFNAME 9 #define SCE_P_OPERATOR 10 #define SCE_P_IDENTIFIER 11 #define SCE_P_COMMENTBLOCK 12 #define SCE_P_STRINGEOL 13 #define SCE_P_WORD2 14 #define SCE_P_DECORATOR 15 #define SCE_P_FSTRING 16 #define SCE_P_FCHARACTER 17 #define SCE_P_FTRIPLE 18 #define SCE_P_FTRIPLEDOUBLE 19 #define SCE_P_ATTRIBUTE 20 #define SCE_C_DEFAULT 0 #define SCE_C_COMMENT 1 #define SCE_C_COMMENTLINE 2 #define SCE_C_COMMENTDOC 3 #define SCE_C_NUMBER 4 #define SCE_C_WORD 5 #define SCE_C_STRING 6 #define SCE_C_CHARACTER 7 #define SCE_C_UUID 8 #define SCE_C_PREPROCESSOR 9 #define SCE_C_OPERATOR 10 #define SCE_C_IDENTIFIER 11 #define SCE_C_STRINGEOL 12 #define SCE_C_VERBATIM 13 #define SCE_C_REGEX 14 #define SCE_C_COMMENTLINEDOC 15 #define SCE_C_WORD2 16 #define SCE_C_COMMENTDOCKEYWORD 17 #define SCE_C_COMMENTDOCKEYWORDERROR 18 #define SCE_C_GLOBALCLASS 19 #define SCE_C_STRINGRAW 20 #define SCE_C_TRIPLEVERBATIM 21 #define SCE_C_HASHQUOTEDSTRING 22 #define SCE_C_PREPROCESSORCOMMENT 23 #define SCE_C_PREPROCESSORCOMMENTDOC 24 #define SCE_C_USERLITERAL 25 #define SCE_C_TASKMARKER 26 #define SCE_C_ESCAPESEQUENCE 27 #define SCE_COBOL_DEFAULT 0 #define SCE_COBOL_COMMENT 1 #define SCE_COBOL_COMMENTLINE 2 #define SCE_COBOL_COMMENTDOC 3 #define SCE_COBOL_NUMBER 4 #define SCE_COBOL_WORD 5 #define SCE_COBOL_STRING 6 #define SCE_COBOL_CHARACTER 7 #define SCE_COBOL_WORD3 8 #define SCE_COBOL_PREPROCESSOR 9 #define SCE_COBOL_OPERATOR 10 #define SCE_COBOL_IDENTIFIER 11 #define SCE_COBOL_WORD2 16 #define SCE_D_DEFAULT 0 #define SCE_D_COMMENT 1 #define SCE_D_COMMENTLINE 2 #define SCE_D_COMMENTDOC 3 #define SCE_D_COMMENTNESTED 4 #define SCE_D_NUMBER 5 #define SCE_D_WORD 6 #define SCE_D_WORD2 7 #define SCE_D_WORD3 8 #define SCE_D_TYPEDEF 9 #define SCE_D_STRING 10 #define SCE_D_STRINGEOL 11 #define SCE_D_CHARACTER 12 #define SCE_D_OPERATOR 13 #define SCE_D_IDENTIFIER 14 #define SCE_D_COMMENTLINEDOC 15 #define SCE_D_COMMENTDOCKEYWORD 16 #define SCE_D_COMMENTDOCKEYWORDERROR 17 #define SCE_D_STRINGB 18 #define SCE_D_STRINGR 19 #define SCE_D_WORD5 20 #define SCE_D_WORD6 21 #define SCE_D_WORD7 22 #define SCE_TCL_DEFAULT 0 #define SCE_TCL_COMMENT 1 #define SCE_TCL_COMMENTLINE 2 #define SCE_TCL_NUMBER 3 #define SCE_TCL_WORD_IN_QUOTE 4 #define SCE_TCL_IN_QUOTE 5 #define SCE_TCL_OPERATOR 6 #define SCE_TCL_IDENTIFIER 7 #define SCE_TCL_SUBSTITUTION 8 #define SCE_TCL_SUB_BRACE 9 #define SCE_TCL_MODIFIER 10 #define SCE_TCL_EXPAND 11 #define SCE_TCL_WORD 12 #define SCE_TCL_WORD2 13 #define SCE_TCL_WORD3 14 #define SCE_TCL_WORD4 15 #define SCE_TCL_WORD5 16 #define SCE_TCL_WORD6 17 #define SCE_TCL_WORD7 18 #define SCE_TCL_WORD8 19 #define SCE_TCL_COMMENT_BOX 20 #define SCE_TCL_BLOCK_COMMENT 21 #define SCE_H_DEFAULT 0 #define SCE_H_TAG 1 #define SCE_H_TAGUNKNOWN 2 #define SCE_H_ATTRIBUTE 3 #define SCE_H_ATTRIBUTEUNKNOWN 4 #define SCE_H_NUMBER 5 #define SCE_H_DOUBLESTRING 6 #define SCE_H_SINGLESTRING 7 #define SCE_H_OTHER 8 #define SCE_H_COMMENT 9 #define SCE_H_ENTITY 10 #define SCE_H_TAGEND 11 #define SCE_H_XMLSTART 12 #define SCE_H_XMLEND 13 #define SCE_H_SCRIPT 14 #define SCE_H_ASP 15 #define SCE_H_ASPAT 16 #define SCE_H_CDATA 17 #define SCE_H_QUESTION 18 #define SCE_H_VALUE 19 #define SCE_H_XCCOMMENT 20 #define SCE_H_SGML_DEFAULT 21 #define SCE_H_SGML_COMMAND 22 #define SCE_H_SGML_1ST_PARAM 23 #define SCE_H_SGML_DOUBLESTRING 24 #define SCE_H_SGML_SIMPLESTRING 25 #define SCE_H_SGML_ERROR 26 #define SCE_H_SGML_SPECIAL 27 #define SCE_H_SGML_ENTITY 28 #define SCE_H_SGML_COMMENT 29 #define SCE_H_SGML_1ST_PARAM_COMMENT 30 #define SCE_H_SGML_BLOCK_DEFAULT 31 #define SCE_HJ_START 40 #define SCE_HJ_DEFAULT 41 #define SCE_HJ_COMMENT 42 #define SCE_HJ_COMMENTLINE 43 #define SCE_HJ_COMMENTDOC 44 #define SCE_HJ_NUMBER 45 #define SCE_HJ_WORD 46 #define SCE_HJ_KEYWORD 47 #define SCE_HJ_DOUBLESTRING 48 #define SCE_HJ_SINGLESTRING 49 #define SCE_HJ_SYMBOLS 50 #define SCE_HJ_STRINGEOL 51 #define SCE_HJ_REGEX 52 #define SCE_HJ_TEMPLATELITERAL 53 #define SCE_HJA_START 55 #define SCE_HJA_DEFAULT 56 #define SCE_HJA_COMMENT 57 #define SCE_HJA_COMMENTLINE 58 #define SCE_HJA_COMMENTDOC 59 #define SCE_HJA_NUMBER 60 #define SCE_HJA_WORD 61 #define SCE_HJA_KEYWORD 62 #define SCE_HJA_DOUBLESTRING 63 #define SCE_HJA_SINGLESTRING 64 #define SCE_HJA_SYMBOLS 65 #define SCE_HJA_STRINGEOL 66 #define SCE_HJA_REGEX 67 #define SCE_HJA_TEMPLATELITERAL 68 #define SCE_HB_START 70 #define SCE_HB_DEFAULT 71 #define SCE_HB_COMMENTLINE 72 #define SCE_HB_NUMBER 73 #define SCE_HB_WORD 74 #define SCE_HB_STRING 75 #define SCE_HB_IDENTIFIER 76 #define SCE_HB_STRINGEOL 77 #define SCE_HBA_START 80 #define SCE_HBA_DEFAULT 81 #define SCE_HBA_COMMENTLINE 82 #define SCE_HBA_NUMBER 83 #define SCE_HBA_WORD 84 #define SCE_HBA_STRING 85 #define SCE_HBA_IDENTIFIER 86 #define SCE_HBA_STRINGEOL 87 #define SCE_HP_START 90 #define SCE_HP_DEFAULT 91 #define SCE_HP_COMMENTLINE 92 #define SCE_HP_NUMBER 93 #define SCE_HP_STRING 94 #define SCE_HP_CHARACTER 95 #define SCE_HP_WORD 96 #define SCE_HP_TRIPLE 97 #define SCE_HP_TRIPLEDOUBLE 98 #define SCE_HP_CLASSNAME 99 #define SCE_HP_DEFNAME 100 #define SCE_HP_OPERATOR 101 #define SCE_HP_IDENTIFIER 102 #define SCE_HPHP_COMPLEX_VARIABLE 104 #define SCE_HPA_START 105 #define SCE_HPA_DEFAULT 106 #define SCE_HPA_COMMENTLINE 107 #define SCE_HPA_NUMBER 108 #define SCE_HPA_STRING 109 #define SCE_HPA_CHARACTER 110 #define SCE_HPA_WORD 111 #define SCE_HPA_TRIPLE 112 #define SCE_HPA_TRIPLEDOUBLE 113 #define SCE_HPA_CLASSNAME 114 #define SCE_HPA_DEFNAME 115 #define SCE_HPA_OPERATOR 116 #define SCE_HPA_IDENTIFIER 117 #define SCE_HPHP_DEFAULT 118 #define SCE_HPHP_HSTRING 119 #define SCE_HPHP_SIMPLESTRING 120 #define SCE_HPHP_WORD 121 #define SCE_HPHP_NUMBER 122 #define SCE_HPHP_VARIABLE 123 #define SCE_HPHP_COMMENT 124 #define SCE_HPHP_COMMENTLINE 125 #define SCE_HPHP_HSTRING_VARIABLE 126 #define SCE_HPHP_OPERATOR 127 #define SCE_PL_DEFAULT 0 #define SCE_PL_ERROR 1 #define SCE_PL_COMMENTLINE 2 #define SCE_PL_POD 3 #define SCE_PL_NUMBER 4 #define SCE_PL_WORD 5 #define SCE_PL_STRING 6 #define SCE_PL_CHARACTER 7 #define SCE_PL_PUNCTUATION 8 #define SCE_PL_PREPROCESSOR 9 #define SCE_PL_OPERATOR 10 #define SCE_PL_IDENTIFIER 11 #define SCE_PL_SCALAR 12 #define SCE_PL_ARRAY 13 #define SCE_PL_HASH 14 #define SCE_PL_SYMBOLTABLE 15 #define SCE_PL_VARIABLE_INDEXER 16 #define SCE_PL_REGEX 17 #define SCE_PL_REGSUBST 18 #define SCE_PL_LONGQUOTE 19 #define SCE_PL_BACKTICKS 20 #define SCE_PL_DATASECTION 21 #define SCE_PL_HERE_DELIM 22 #define SCE_PL_HERE_Q 23 #define SCE_PL_HERE_QQ 24 #define SCE_PL_HERE_QX 25 #define SCE_PL_STRING_Q 26 #define SCE_PL_STRING_QQ 27 #define SCE_PL_STRING_QX 28 #define SCE_PL_STRING_QR 29 #define SCE_PL_STRING_QW 30 #define SCE_PL_POD_VERB 31 #define SCE_PL_SUB_PROTOTYPE 40 #define SCE_PL_FORMAT_IDENT 41 #define SCE_PL_FORMAT 42 #define SCE_PL_STRING_VAR 43 #define SCE_PL_XLAT 44 #define SCE_PL_REGEX_VAR 54 #define SCE_PL_REGSUBST_VAR 55 #define SCE_PL_BACKTICKS_VAR 57 #define SCE_PL_HERE_QQ_VAR 61 #define SCE_PL_HERE_QX_VAR 62 #define SCE_PL_STRING_QQ_VAR 64 #define SCE_PL_STRING_QX_VAR 65 #define SCE_PL_STRING_QR_VAR 66 #define SCE_RB_DEFAULT 0 #define SCE_RB_ERROR 1 #define SCE_RB_COMMENTLINE 2 #define SCE_RB_POD 3 #define SCE_RB_NUMBER 4 #define SCE_RB_WORD 5 #define SCE_RB_STRING 6 #define SCE_RB_CHARACTER 7 #define SCE_RB_CLASSNAME 8 #define SCE_RB_DEFNAME 9 #define SCE_RB_OPERATOR 10 #define SCE_RB_IDENTIFIER 11 #define SCE_RB_REGEX 12 #define SCE_RB_GLOBAL 13 #define SCE_RB_SYMBOL 14 #define SCE_RB_MODULE_NAME 15 #define SCE_RB_INSTANCE_VAR 16 #define SCE_RB_CLASS_VAR 17 #define SCE_RB_BACKTICKS 18 #define SCE_RB_DATASECTION 19 #define SCE_RB_HERE_DELIM 20 #define SCE_RB_HERE_Q 21 #define SCE_RB_HERE_QQ 22 #define SCE_RB_HERE_QX 23 #define SCE_RB_STRING_Q 24 #define SCE_RB_STRING_QQ 25 #define SCE_RB_STRING_QX 26 #define SCE_RB_STRING_QR 27 #define SCE_RB_STRING_QW 28 #define SCE_RB_WORD_DEMOTED 29 #define SCE_RB_STDIN 30 #define SCE_RB_STDOUT 31 #define SCE_RB_STDERR 40 #define SCE_RB_STRING_W 41 #define SCE_RB_STRING_I 42 #define SCE_RB_STRING_QI 43 #define SCE_RB_STRING_QS 44 #define SCE_RB_UPPER_BOUND 45 #define SCE_B_DEFAULT 0 #define SCE_B_COMMENT 1 #define SCE_B_NUMBER 2 #define SCE_B_KEYWORD 3 #define SCE_B_STRING 4 #define SCE_B_PREPROCESSOR 5 #define SCE_B_OPERATOR 6 #define SCE_B_IDENTIFIER 7 #define SCE_B_DATE 8 #define SCE_B_STRINGEOL 9 #define SCE_B_KEYWORD2 10 #define SCE_B_KEYWORD3 11 #define SCE_B_KEYWORD4 12 #define SCE_B_CONSTANT 13 #define SCE_B_ASM 14 #define SCE_B_LABEL 15 #define SCE_B_ERROR 16 #define SCE_B_HEXNUMBER 17 #define SCE_B_BINNUMBER 18 #define SCE_B_COMMENTBLOCK 19 #define SCE_B_DOCLINE 20 #define SCE_B_DOCBLOCK 21 #define SCE_B_DOCKEYWORD 22 #define SCE_PROPS_DEFAULT 0 #define SCE_PROPS_COMMENT 1 #define SCE_PROPS_SECTION 2 #define SCE_PROPS_ASSIGNMENT 3 #define SCE_PROPS_DEFVAL 4 #define SCE_PROPS_KEY 5 #define SCE_L_DEFAULT 0 #define SCE_L_COMMAND 1 #define SCE_L_TAG 2 #define SCE_L_MATH 3 #define SCE_L_COMMENT 4 #define SCE_L_TAG2 5 #define SCE_L_MATH2 6 #define SCE_L_COMMENT2 7 #define SCE_L_VERBATIM 8 #define SCE_L_SHORTCMD 9 #define SCE_L_SPECIAL 10 #define SCE_L_CMDOPT 11 #define SCE_L_ERROR 12 #define SCE_LUA_DEFAULT 0 #define SCE_LUA_COMMENT 1 #define SCE_LUA_COMMENTLINE 2 #define SCE_LUA_COMMENTDOC 3 #define SCE_LUA_NUMBER 4 #define SCE_LUA_WORD 5 #define SCE_LUA_STRING 6 #define SCE_LUA_CHARACTER 7 #define SCE_LUA_LITERALSTRING 8 #define SCE_LUA_PREPROCESSOR 9 #define SCE_LUA_OPERATOR 10 #define SCE_LUA_IDENTIFIER 11 #define SCE_LUA_STRINGEOL 12 #define SCE_LUA_WORD2 13 #define SCE_LUA_WORD3 14 #define SCE_LUA_WORD4 15 #define SCE_LUA_WORD5 16 #define SCE_LUA_WORD6 17 #define SCE_LUA_WORD7 18 #define SCE_LUA_WORD8 19 #define SCE_LUA_LABEL 20 #define SCE_ERR_DEFAULT 0 #define SCE_ERR_PYTHON 1 #define SCE_ERR_GCC 2 #define SCE_ERR_MS 3 #define SCE_ERR_CMD 4 #define SCE_ERR_BORLAND 5 #define SCE_ERR_PERL 6 #define SCE_ERR_NET 7 #define SCE_ERR_LUA 8 #define SCE_ERR_CTAG 9 #define SCE_ERR_DIFF_CHANGED 10 #define SCE_ERR_DIFF_ADDITION 11 #define SCE_ERR_DIFF_DELETION 12 #define SCE_ERR_DIFF_MESSAGE 13 #define SCE_ERR_PHP 14 #define SCE_ERR_ELF 15 #define SCE_ERR_IFC 16 #define SCE_ERR_IFORT 17 #define SCE_ERR_ABSF 18 #define SCE_ERR_TIDY 19 #define SCE_ERR_JAVA_STACK 20 #define SCE_ERR_VALUE 21 #define SCE_ERR_GCC_INCLUDED_FROM 22 #define SCE_ERR_ESCSEQ 23 #define SCE_ERR_ESCSEQ_UNKNOWN 24 #define SCE_ERR_GCC_EXCERPT 25 #define SCE_ERR_BASH 26 #define SCE_ERR_ES_BLACK 40 #define SCE_ERR_ES_RED 41 #define SCE_ERR_ES_GREEN 42 #define SCE_ERR_ES_BROWN 43 #define SCE_ERR_ES_BLUE 44 #define SCE_ERR_ES_MAGENTA 45 #define SCE_ERR_ES_CYAN 46 #define SCE_ERR_ES_GRAY 47 #define SCE_ERR_ES_DARK_GRAY 48 #define SCE_ERR_ES_BRIGHT_RED 49 #define SCE_ERR_ES_BRIGHT_GREEN 50 #define SCE_ERR_ES_YELLOW 51 #define SCE_ERR_ES_BRIGHT_BLUE 52 #define SCE_ERR_ES_BRIGHT_MAGENTA 53 #define SCE_ERR_ES_BRIGHT_CYAN 54 #define SCE_ERR_ES_WHITE 55 #define SCE_BAT_DEFAULT 0 #define SCE_BAT_COMMENT 1 #define SCE_BAT_WORD 2 #define SCE_BAT_LABEL 3 #define SCE_BAT_HIDE 4 #define SCE_BAT_COMMAND 5 #define SCE_BAT_IDENTIFIER 6 #define SCE_BAT_OPERATOR 7 #define SCE_BAT_AFTER_LABEL 8 #define SCE_TCMD_DEFAULT 0 #define SCE_TCMD_COMMENT 1 #define SCE_TCMD_WORD 2 #define SCE_TCMD_LABEL 3 #define SCE_TCMD_HIDE 4 #define SCE_TCMD_COMMAND 5 #define SCE_TCMD_IDENTIFIER 6 #define SCE_TCMD_OPERATOR 7 #define SCE_TCMD_ENVIRONMENT 8 #define SCE_TCMD_EXPANSION 9 #define SCE_TCMD_CLABEL 10 #define SCE_MAKE_DEFAULT 0 #define SCE_MAKE_COMMENT 1 #define SCE_MAKE_PREPROCESSOR 2 #define SCE_MAKE_IDENTIFIER 3 #define SCE_MAKE_OPERATOR 4 #define SCE_MAKE_TARGET 5 #define SCE_MAKE_IDEOL 9 #define SCE_DIFF_DEFAULT 0 #define SCE_DIFF_COMMENT 1 #define SCE_DIFF_COMMAND 2 #define SCE_DIFF_HEADER 3 #define SCE_DIFF_POSITION 4 #define SCE_DIFF_DELETED 5 #define SCE_DIFF_ADDED 6 #define SCE_DIFF_CHANGED 7 #define SCE_DIFF_PATCH_ADD 8 #define SCE_DIFF_PATCH_DELETE 9 #define SCE_DIFF_REMOVED_PATCH_ADD 10 #define SCE_DIFF_REMOVED_PATCH_DELETE 11 #define SCE_CONF_DEFAULT 0 #define SCE_CONF_COMMENT 1 #define SCE_CONF_NUMBER 2 #define SCE_CONF_IDENTIFIER 3 #define SCE_CONF_EXTENSION 4 #define SCE_CONF_PARAMETER 5 #define SCE_CONF_STRING 6 #define SCE_CONF_OPERATOR 7 #define SCE_CONF_IP 8 #define SCE_CONF_DIRECTIVE 9 #define SCE_AVE_DEFAULT 0 #define SCE_AVE_COMMENT 1 #define SCE_AVE_NUMBER 2 #define SCE_AVE_WORD 3 #define SCE_AVE_STRING 6 #define SCE_AVE_ENUM 7 #define SCE_AVE_STRINGEOL 8 #define SCE_AVE_IDENTIFIER 9 #define SCE_AVE_OPERATOR 10 #define SCE_AVE_WORD1 11 #define SCE_AVE_WORD2 12 #define SCE_AVE_WORD3 13 #define SCE_AVE_WORD4 14 #define SCE_AVE_WORD5 15 #define SCE_AVE_WORD6 16 #define SCE_ADA_DEFAULT 0 #define SCE_ADA_WORD 1 #define SCE_ADA_IDENTIFIER 2 #define SCE_ADA_NUMBER 3 #define SCE_ADA_DELIMITER 4 #define SCE_ADA_CHARACTER 5 #define SCE_ADA_CHARACTEREOL 6 #define SCE_ADA_STRING 7 #define SCE_ADA_STRINGEOL 8 #define SCE_ADA_LABEL 9 #define SCE_ADA_COMMENTLINE 10 #define SCE_ADA_ILLEGAL 11 #define SCE_BAAN_DEFAULT 0 #define SCE_BAAN_COMMENT 1 #define SCE_BAAN_COMMENTDOC 2 #define SCE_BAAN_NUMBER 3 #define SCE_BAAN_WORD 4 #define SCE_BAAN_STRING 5 #define SCE_BAAN_PREPROCESSOR 6 #define SCE_BAAN_OPERATOR 7 #define SCE_BAAN_IDENTIFIER 8 #define SCE_BAAN_STRINGEOL 9 #define SCE_BAAN_WORD2 10 #define SCE_BAAN_WORD3 11 #define SCE_BAAN_WORD4 12 #define SCE_BAAN_WORD5 13 #define SCE_BAAN_WORD6 14 #define SCE_BAAN_WORD7 15 #define SCE_BAAN_WORD8 16 #define SCE_BAAN_WORD9 17 #define SCE_BAAN_TABLEDEF 18 #define SCE_BAAN_TABLESQL 19 #define SCE_BAAN_FUNCTION 20 #define SCE_BAAN_DOMDEF 21 #define SCE_BAAN_FUNCDEF 22 #define SCE_BAAN_OBJECTDEF 23 #define SCE_BAAN_DEFINEDEF 24 #define SCE_LISP_DEFAULT 0 #define SCE_LISP_COMMENT 1 #define SCE_LISP_NUMBER 2 #define SCE_LISP_KEYWORD 3 #define SCE_LISP_KEYWORD_KW 4 #define SCE_LISP_SYMBOL 5 #define SCE_LISP_STRING 6 #define SCE_LISP_STRINGEOL 8 #define SCE_LISP_IDENTIFIER 9 #define SCE_LISP_OPERATOR 10 #define SCE_LISP_SPECIAL 11 #define SCE_LISP_MULTI_COMMENT 12 #define SCE_EIFFEL_DEFAULT 0 #define SCE_EIFFEL_COMMENTLINE 1 #define SCE_EIFFEL_NUMBER 2 #define SCE_EIFFEL_WORD 3 #define SCE_EIFFEL_STRING 4 #define SCE_EIFFEL_CHARACTER 5 #define SCE_EIFFEL_OPERATOR 6 #define SCE_EIFFEL_IDENTIFIER 7 #define SCE_EIFFEL_STRINGEOL 8 #define SCE_NNCRONTAB_DEFAULT 0 #define SCE_NNCRONTAB_COMMENT 1 #define SCE_NNCRONTAB_TASK 2 #define SCE_NNCRONTAB_SECTION 3 #define SCE_NNCRONTAB_KEYWORD 4 #define SCE_NNCRONTAB_MODIFIER 5 #define SCE_NNCRONTAB_ASTERISK 6 #define SCE_NNCRONTAB_NUMBER 7 #define SCE_NNCRONTAB_STRING 8 #define SCE_NNCRONTAB_ENVIRONMENT 9 #define SCE_NNCRONTAB_IDENTIFIER 10 #define SCE_FORTH_DEFAULT 0 #define SCE_FORTH_COMMENT 1 #define SCE_FORTH_COMMENT_ML 2 #define SCE_FORTH_IDENTIFIER 3 #define SCE_FORTH_CONTROL 4 #define SCE_FORTH_KEYWORD 5 #define SCE_FORTH_DEFWORD 6 #define SCE_FORTH_PREWORD1 7 #define SCE_FORTH_PREWORD2 8 #define SCE_FORTH_NUMBER 9 #define SCE_FORTH_STRING 10 #define SCE_FORTH_LOCALE 11 #define SCE_MATLAB_DEFAULT 0 #define SCE_MATLAB_COMMENT 1 #define SCE_MATLAB_COMMAND 2 #define SCE_MATLAB_NUMBER 3 #define SCE_MATLAB_KEYWORD 4 #define SCE_MATLAB_STRING 5 #define SCE_MATLAB_OPERATOR 6 #define SCE_MATLAB_IDENTIFIER 7 #define SCE_MATLAB_DOUBLEQUOTESTRING 8 #define SCE_MAXIMA_OPERATOR 0 #define SCE_MAXIMA_COMMANDENDING 1 #define SCE_MAXIMA_COMMENT 2 #define SCE_MAXIMA_NUMBER 3 #define SCE_MAXIMA_STRING 4 #define SCE_MAXIMA_COMMAND 5 #define SCE_MAXIMA_VARIABLE 6 #define SCE_MAXIMA_UNKNOWN 7 #define SCE_SCRIPTOL_DEFAULT 0 #define SCE_SCRIPTOL_WHITE 1 #define SCE_SCRIPTOL_COMMENTLINE 2 #define SCE_SCRIPTOL_PERSISTENT 3 #define SCE_SCRIPTOL_CSTYLE 4 #define SCE_SCRIPTOL_COMMENTBLOCK 5 #define SCE_SCRIPTOL_NUMBER 6 #define SCE_SCRIPTOL_STRING 7 #define SCE_SCRIPTOL_CHARACTER 8 #define SCE_SCRIPTOL_STRINGEOL 9 #define SCE_SCRIPTOL_KEYWORD 10 #define SCE_SCRIPTOL_OPERATOR 11 #define SCE_SCRIPTOL_IDENTIFIER 12 #define SCE_SCRIPTOL_TRIPLE 13 #define SCE_SCRIPTOL_CLASSNAME 14 #define SCE_SCRIPTOL_PREPROCESSOR 15 #define SCE_ASM_DEFAULT 0 #define SCE_ASM_COMMENT 1 #define SCE_ASM_NUMBER 2 #define SCE_ASM_STRING 3 #define SCE_ASM_OPERATOR 4 #define SCE_ASM_IDENTIFIER 5 #define SCE_ASM_CPUINSTRUCTION 6 #define SCE_ASM_MATHINSTRUCTION 7 #define SCE_ASM_REGISTER 8 #define SCE_ASM_DIRECTIVE 9 #define SCE_ASM_DIRECTIVEOPERAND 10 #define SCE_ASM_COMMENTBLOCK 11 #define SCE_ASM_CHARACTER 12 #define SCE_ASM_STRINGEOL 13 #define SCE_ASM_EXTINSTRUCTION 14 #define SCE_ASM_COMMENTDIRECTIVE 15 #define SCE_F_DEFAULT 0 #define SCE_F_COMMENT 1 #define SCE_F_NUMBER 2 #define SCE_F_STRING1 3 #define SCE_F_STRING2 4 #define SCE_F_STRINGEOL 5 #define SCE_F_OPERATOR 6 #define SCE_F_IDENTIFIER 7 #define SCE_F_WORD 8 #define SCE_F_WORD2 9 #define SCE_F_WORD3 10 #define SCE_F_PREPROCESSOR 11 #define SCE_F_OPERATOR2 12 #define SCE_F_LABEL 13 #define SCE_F_CONTINUATION 14 #define SCE_CSS_DEFAULT 0 #define SCE_CSS_TAG 1 #define SCE_CSS_CLASS 2 #define SCE_CSS_PSEUDOCLASS 3 #define SCE_CSS_UNKNOWN_PSEUDOCLASS 4 #define SCE_CSS_OPERATOR 5 #define SCE_CSS_IDENTIFIER 6 #define SCE_CSS_UNKNOWN_IDENTIFIER 7 #define SCE_CSS_VALUE 8 #define SCE_CSS_COMMENT 9 #define SCE_CSS_ID 10 #define SCE_CSS_IMPORTANT 11 #define SCE_CSS_DIRECTIVE 12 #define SCE_CSS_DOUBLESTRING 13 #define SCE_CSS_SINGLESTRING 14 #define SCE_CSS_IDENTIFIER2 15 #define SCE_CSS_ATTRIBUTE 16 #define SCE_CSS_IDENTIFIER3 17 #define SCE_CSS_PSEUDOELEMENT 18 #define SCE_CSS_EXTENDED_IDENTIFIER 19 #define SCE_CSS_EXTENDED_PSEUDOCLASS 20 #define SCE_CSS_EXTENDED_PSEUDOELEMENT 21 #define SCE_CSS_GROUP_RULE 22 #define SCE_CSS_VARIABLE 23 #define SCE_POV_DEFAULT 0 #define SCE_POV_COMMENT 1 #define SCE_POV_COMMENTLINE 2 #define SCE_POV_NUMBER 3 #define SCE_POV_OPERATOR 4 #define SCE_POV_IDENTIFIER 5 #define SCE_POV_STRING 6 #define SCE_POV_STRINGEOL 7 #define SCE_POV_DIRECTIVE 8 #define SCE_POV_BADDIRECTIVE 9 #define SCE_POV_WORD2 10 #define SCE_POV_WORD3 11 #define SCE_POV_WORD4 12 #define SCE_POV_WORD5 13 #define SCE_POV_WORD6 14 #define SCE_POV_WORD7 15 #define SCE_POV_WORD8 16 #define SCE_LOUT_DEFAULT 0 #define SCE_LOUT_COMMENT 1 #define SCE_LOUT_NUMBER 2 #define SCE_LOUT_WORD 3 #define SCE_LOUT_WORD2 4 #define SCE_LOUT_WORD3 5 #define SCE_LOUT_WORD4 6 #define SCE_LOUT_STRING 7 #define SCE_LOUT_OPERATOR 8 #define SCE_LOUT_IDENTIFIER 9 #define SCE_LOUT_STRINGEOL 10 #define SCE_ESCRIPT_DEFAULT 0 #define SCE_ESCRIPT_COMMENT 1 #define SCE_ESCRIPT_COMMENTLINE 2 #define SCE_ESCRIPT_COMMENTDOC 3 #define SCE_ESCRIPT_NUMBER 4 #define SCE_ESCRIPT_WORD 5 #define SCE_ESCRIPT_STRING 6 #define SCE_ESCRIPT_OPERATOR 7 #define SCE_ESCRIPT_IDENTIFIER 8 #define SCE_ESCRIPT_BRACE 9 #define SCE_ESCRIPT_WORD2 10 #define SCE_ESCRIPT_WORD3 11 #define SCE_PS_DEFAULT 0 #define SCE_PS_COMMENT 1 #define SCE_PS_DSC_COMMENT 2 #define SCE_PS_DSC_VALUE 3 #define SCE_PS_NUMBER 4 #define SCE_PS_NAME 5 #define SCE_PS_KEYWORD 6 #define SCE_PS_LITERAL 7 #define SCE_PS_IMMEVAL 8 #define SCE_PS_PAREN_ARRAY 9 #define SCE_PS_PAREN_DICT 10 #define SCE_PS_PAREN_PROC 11 #define SCE_PS_TEXT 12 #define SCE_PS_HEXSTRING 13 #define SCE_PS_BASE85STRING 14 #define SCE_PS_BADSTRINGCHAR 15 #define SCE_NSIS_DEFAULT 0 #define SCE_NSIS_COMMENT 1 #define SCE_NSIS_STRINGDQ 2 #define SCE_NSIS_STRINGLQ 3 #define SCE_NSIS_STRINGRQ 4 #define SCE_NSIS_FUNCTION 5 #define SCE_NSIS_VARIABLE 6 #define SCE_NSIS_LABEL 7 #define SCE_NSIS_USERDEFINED 8 #define SCE_NSIS_SECTIONDEF 9 #define SCE_NSIS_SUBSECTIONDEF 10 #define SCE_NSIS_IFDEFINEDEF 11 #define SCE_NSIS_MACRODEF 12 #define SCE_NSIS_STRINGVAR 13 #define SCE_NSIS_NUMBER 14 #define SCE_NSIS_SECTIONGROUP 15 #define SCE_NSIS_PAGEEX 16 #define SCE_NSIS_FUNCTIONDEF 17 #define SCE_NSIS_COMMENTBOX 18 #define SCE_MMIXAL_LEADWS 0 #define SCE_MMIXAL_COMMENT 1 #define SCE_MMIXAL_LABEL 2 #define SCE_MMIXAL_OPCODE 3 #define SCE_MMIXAL_OPCODE_PRE 4 #define SCE_MMIXAL_OPCODE_VALID 5 #define SCE_MMIXAL_OPCODE_UNKNOWN 6 #define SCE_MMIXAL_OPCODE_POST 7 #define SCE_MMIXAL_OPERANDS 8 #define SCE_MMIXAL_NUMBER 9 #define SCE_MMIXAL_REF 10 #define SCE_MMIXAL_CHAR 11 #define SCE_MMIXAL_STRING 12 #define SCE_MMIXAL_REGISTER 13 #define SCE_MMIXAL_HEX 14 #define SCE_MMIXAL_OPERATOR 15 #define SCE_MMIXAL_SYMBOL 16 #define SCE_MMIXAL_INCLUDE 17 #define SCE_CLW_DEFAULT 0 #define SCE_CLW_LABEL 1 #define SCE_CLW_COMMENT 2 #define SCE_CLW_STRING 3 #define SCE_CLW_USER_IDENTIFIER 4 #define SCE_CLW_INTEGER_CONSTANT 5 #define SCE_CLW_REAL_CONSTANT 6 #define SCE_CLW_PICTURE_STRING 7 #define SCE_CLW_KEYWORD 8 #define SCE_CLW_COMPILER_DIRECTIVE 9 #define SCE_CLW_RUNTIME_EXPRESSIONS 10 #define SCE_CLW_BUILTIN_PROCEDURES_FUNCTION 11 #define SCE_CLW_STRUCTURE_DATA_TYPE 12 #define SCE_CLW_ATTRIBUTE 13 #define SCE_CLW_STANDARD_EQUATE 14 #define SCE_CLW_ERROR 15 #define SCE_CLW_DEPRECATED 16 #define SCE_LOT_DEFAULT 0 #define SCE_LOT_HEADER 1 #define SCE_LOT_BREAK 2 #define SCE_LOT_SET 3 #define SCE_LOT_PASS 4 #define SCE_LOT_FAIL 5 #define SCE_LOT_ABORT 6 #define SCE_YAML_DEFAULT 0 #define SCE_YAML_COMMENT 1 #define SCE_YAML_IDENTIFIER 2 #define SCE_YAML_KEYWORD 3 #define SCE_YAML_NUMBER 4 #define SCE_YAML_REFERENCE 5 #define SCE_YAML_DOCUMENT 6 #define SCE_YAML_TEXT 7 #define SCE_YAML_ERROR 8 #define SCE_YAML_OPERATOR 9 #define SCE_TEX_DEFAULT 0 #define SCE_TEX_SPECIAL 1 #define SCE_TEX_GROUP 2 #define SCE_TEX_SYMBOL 3 #define SCE_TEX_COMMAND 4 #define SCE_TEX_TEXT 5 #define SCE_METAPOST_DEFAULT 0 #define SCE_METAPOST_SPECIAL 1 #define SCE_METAPOST_GROUP 2 #define SCE_METAPOST_SYMBOL 3 #define SCE_METAPOST_COMMAND 4 #define SCE_METAPOST_TEXT 5 #define SCE_METAPOST_EXTRA 6 #define SCE_ERLANG_DEFAULT 0 #define SCE_ERLANG_COMMENT 1 #define SCE_ERLANG_VARIABLE 2 #define SCE_ERLANG_NUMBER 3 #define SCE_ERLANG_KEYWORD 4 #define SCE_ERLANG_STRING 5 #define SCE_ERLANG_OPERATOR 6 #define SCE_ERLANG_ATOM 7 #define SCE_ERLANG_FUNCTION_NAME 8 #define SCE_ERLANG_CHARACTER 9 #define SCE_ERLANG_MACRO 10 #define SCE_ERLANG_RECORD 11 #define SCE_ERLANG_PREPROC 12 #define SCE_ERLANG_NODE_NAME 13 #define SCE_ERLANG_COMMENT_FUNCTION 14 #define SCE_ERLANG_COMMENT_MODULE 15 #define SCE_ERLANG_COMMENT_DOC 16 #define SCE_ERLANG_COMMENT_DOC_MACRO 17 #define SCE_ERLANG_ATOM_QUOTED 18 #define SCE_ERLANG_MACRO_QUOTED 19 #define SCE_ERLANG_RECORD_QUOTED 20 #define SCE_ERLANG_NODE_NAME_QUOTED 21 #define SCE_ERLANG_BIFS 22 #define SCE_ERLANG_MODULES 23 #define SCE_ERLANG_MODULES_ATT 24 #define SCE_ERLANG_UNKNOWN 31 #define SCE_JULIA_DEFAULT 0 #define SCE_JULIA_COMMENT 1 #define SCE_JULIA_NUMBER 2 #define SCE_JULIA_KEYWORD1 3 #define SCE_JULIA_KEYWORD2 4 #define SCE_JULIA_KEYWORD3 5 #define SCE_JULIA_CHAR 6 #define SCE_JULIA_OPERATOR 7 #define SCE_JULIA_BRACKET 8 #define SCE_JULIA_IDENTIFIER 9 #define SCE_JULIA_STRING 10 #define SCE_JULIA_SYMBOL 11 #define SCE_JULIA_MACRO 12 #define SCE_JULIA_STRINGINTERP 13 #define SCE_JULIA_DOCSTRING 14 #define SCE_JULIA_STRINGLITERAL 15 #define SCE_JULIA_COMMAND 16 #define SCE_JULIA_COMMANDLITERAL 17 #define SCE_JULIA_TYPEANNOT 18 #define SCE_JULIA_LEXERROR 19 #define SCE_JULIA_KEYWORD4 20 #define SCE_JULIA_TYPEOPERATOR 21 #define SCE_MSSQL_DEFAULT 0 #define SCE_MSSQL_COMMENT 1 #define SCE_MSSQL_LINE_COMMENT 2 #define SCE_MSSQL_NUMBER 3 #define SCE_MSSQL_STRING 4 #define SCE_MSSQL_OPERATOR 5 #define SCE_MSSQL_IDENTIFIER 6 #define SCE_MSSQL_VARIABLE 7 #define SCE_MSSQL_COLUMN_NAME 8 #define SCE_MSSQL_STATEMENT 9 #define SCE_MSSQL_DATATYPE 10 #define SCE_MSSQL_SYSTABLE 11 #define SCE_MSSQL_GLOBAL_VARIABLE 12 #define SCE_MSSQL_FUNCTION 13 #define SCE_MSSQL_STORED_PROCEDURE 14 #define SCE_MSSQL_DEFAULT_PREF_DATATYPE 15 #define SCE_MSSQL_COLUMN_NAME_2 16 #define SCE_V_DEFAULT 0 #define SCE_V_COMMENT 1 #define SCE_V_COMMENTLINE 2 #define SCE_V_COMMENTLINEBANG 3 #define SCE_V_NUMBER 4 #define SCE_V_WORD 5 #define SCE_V_STRING 6 #define SCE_V_WORD2 7 #define SCE_V_WORD3 8 #define SCE_V_PREPROCESSOR 9 #define SCE_V_OPERATOR 10 #define SCE_V_IDENTIFIER 11 #define SCE_V_STRINGEOL 12 #define SCE_V_USER 19 #define SCE_V_COMMENT_WORD 20 #define SCE_V_INPUT 21 #define SCE_V_OUTPUT 22 #define SCE_V_INOUT 23 #define SCE_V_PORT_CONNECT 24 #define SCE_KIX_DEFAULT 0 #define SCE_KIX_COMMENT 1 #define SCE_KIX_STRING1 2 #define SCE_KIX_STRING2 3 #define SCE_KIX_NUMBER 4 #define SCE_KIX_VAR 5 #define SCE_KIX_MACRO 6 #define SCE_KIX_KEYWORD 7 #define SCE_KIX_FUNCTIONS 8 #define SCE_KIX_OPERATOR 9 #define SCE_KIX_COMMENTSTREAM 10 #define SCE_KIX_IDENTIFIER 31 #define SCE_GC_DEFAULT 0 #define SCE_GC_COMMENTLINE 1 #define SCE_GC_COMMENTBLOCK 2 #define SCE_GC_GLOBAL 3 #define SCE_GC_EVENT 4 #define SCE_GC_ATTRIBUTE 5 #define SCE_GC_CONTROL 6 #define SCE_GC_COMMAND 7 #define SCE_GC_STRING 8 #define SCE_GC_OPERATOR 9 #define SCE_SN_DEFAULT 0 #define SCE_SN_CODE 1 #define SCE_SN_COMMENTLINE 2 #define SCE_SN_COMMENTLINEBANG 3 #define SCE_SN_NUMBER 4 #define SCE_SN_WORD 5 #define SCE_SN_STRING 6 #define SCE_SN_WORD2 7 #define SCE_SN_WORD3 8 #define SCE_SN_PREPROCESSOR 9 #define SCE_SN_OPERATOR 10 #define SCE_SN_IDENTIFIER 11 #define SCE_SN_STRINGEOL 12 #define SCE_SN_REGEXTAG 13 #define SCE_SN_SIGNAL 14 #define SCE_SN_USER 19 #define SCE_AU3_DEFAULT 0 #define SCE_AU3_COMMENT 1 #define SCE_AU3_COMMENTBLOCK 2 #define SCE_AU3_NUMBER 3 #define SCE_AU3_FUNCTION 4 #define SCE_AU3_KEYWORD 5 #define SCE_AU3_MACRO 6 #define SCE_AU3_STRING 7 #define SCE_AU3_OPERATOR 8 #define SCE_AU3_VARIABLE 9 #define SCE_AU3_SENT 10 #define SCE_AU3_PREPROCESSOR 11 #define SCE_AU3_SPECIAL 12 #define SCE_AU3_EXPAND 13 #define SCE_AU3_COMOBJ 14 #define SCE_AU3_UDF 15 #define SCE_APDL_DEFAULT 0 #define SCE_APDL_COMMENT 1 #define SCE_APDL_COMMENTBLOCK 2 #define SCE_APDL_NUMBER 3 #define SCE_APDL_STRING 4 #define SCE_APDL_OPERATOR 5 #define SCE_APDL_WORD 6 #define SCE_APDL_PROCESSOR 7 #define SCE_APDL_COMMAND 8 #define SCE_APDL_SLASHCOMMAND 9 #define SCE_APDL_STARCOMMAND 10 #define SCE_APDL_ARGUMENT 11 #define SCE_APDL_FUNCTION 12 #define SCE_SH_DEFAULT 0 #define SCE_SH_ERROR 1 #define SCE_SH_COMMENTLINE 2 #define SCE_SH_NUMBER 3 #define SCE_SH_WORD 4 #define SCE_SH_STRING 5 #define SCE_SH_CHARACTER 6 #define SCE_SH_OPERATOR 7 #define SCE_SH_IDENTIFIER 8 #define SCE_SH_SCALAR 9 #define SCE_SH_PARAM 10 #define SCE_SH_BACKTICKS 11 #define SCE_SH_HERE_DELIM 12 #define SCE_SH_HERE_Q 13 #define SCE_ASN1_DEFAULT 0 #define SCE_ASN1_COMMENT 1 #define SCE_ASN1_IDENTIFIER 2 #define SCE_ASN1_STRING 3 #define SCE_ASN1_OID 4 #define SCE_ASN1_SCALAR 5 #define SCE_ASN1_KEYWORD 6 #define SCE_ASN1_ATTRIBUTE 7 #define SCE_ASN1_DESCRIPTOR 8 #define SCE_ASN1_TYPE 9 #define SCE_ASN1_OPERATOR 10 #define SCE_VHDL_DEFAULT 0 #define SCE_VHDL_COMMENT 1 #define SCE_VHDL_COMMENTLINEBANG 2 #define SCE_VHDL_NUMBER 3 #define SCE_VHDL_STRING 4 #define SCE_VHDL_OPERATOR 5 #define SCE_VHDL_IDENTIFIER 6 #define SCE_VHDL_STRINGEOL 7 #define SCE_VHDL_KEYWORD 8 #define SCE_VHDL_STDOPERATOR 9 #define SCE_VHDL_ATTRIBUTE 10 #define SCE_VHDL_STDFUNCTION 11 #define SCE_VHDL_STDPACKAGE 12 #define SCE_VHDL_STDTYPE 13 #define SCE_VHDL_USERWORD 14 #define SCE_VHDL_BLOCK_COMMENT 15 #define SCE_CAML_DEFAULT 0 #define SCE_CAML_IDENTIFIER 1 #define SCE_CAML_TAGNAME 2 #define SCE_CAML_KEYWORD 3 #define SCE_CAML_KEYWORD2 4 #define SCE_CAML_KEYWORD3 5 #define SCE_CAML_LINENUM 6 #define SCE_CAML_OPERATOR 7 #define SCE_CAML_NUMBER 8 #define SCE_CAML_CHAR 9 #define SCE_CAML_WHITE 10 #define SCE_CAML_STRING 11 #define SCE_CAML_COMMENT 12 #define SCE_CAML_COMMENT1 13 #define SCE_CAML_COMMENT2 14 #define SCE_CAML_COMMENT3 15 #define SCE_HA_DEFAULT 0 #define SCE_HA_IDENTIFIER 1 #define SCE_HA_KEYWORD 2 #define SCE_HA_NUMBER 3 #define SCE_HA_STRING 4 #define SCE_HA_CHARACTER 5 #define SCE_HA_CLASS 6 #define SCE_HA_MODULE 7 #define SCE_HA_CAPITAL 8 #define SCE_HA_DATA 9 #define SCE_HA_IMPORT 10 #define SCE_HA_OPERATOR 11 #define SCE_HA_INSTANCE 12 #define SCE_HA_COMMENTLINE 13 #define SCE_HA_COMMENTBLOCK 14 #define SCE_HA_COMMENTBLOCK2 15 #define SCE_HA_COMMENTBLOCK3 16 #define SCE_HA_PRAGMA 17 #define SCE_HA_PREPROCESSOR 18 #define SCE_HA_STRINGEOL 19 #define SCE_HA_RESERVED_OPERATOR 20 #define SCE_HA_LITERATE_COMMENT 21 #define SCE_HA_LITERATE_CODEDELIM 22 #define SCE_T3_DEFAULT 0 #define SCE_T3_X_DEFAULT 1 #define SCE_T3_PREPROCESSOR 2 #define SCE_T3_BLOCK_COMMENT 3 #define SCE_T3_LINE_COMMENT 4 #define SCE_T3_OPERATOR 5 #define SCE_T3_KEYWORD 6 #define SCE_T3_NUMBER 7 #define SCE_T3_IDENTIFIER 8 #define SCE_T3_S_STRING 9 #define SCE_T3_D_STRING 10 #define SCE_T3_X_STRING 11 #define SCE_T3_LIB_DIRECTIVE 12 #define SCE_T3_MSG_PARAM 13 #define SCE_T3_HTML_TAG 14 #define SCE_T3_HTML_DEFAULT 15 #define SCE_T3_HTML_STRING 16 #define SCE_T3_USER1 17 #define SCE_T3_USER2 18 #define SCE_T3_USER3 19 #define SCE_T3_BRACE 20 #define SCE_REBOL_DEFAULT 0 #define SCE_REBOL_COMMENTLINE 1 #define SCE_REBOL_COMMENTBLOCK 2 #define SCE_REBOL_PREFACE 3 #define SCE_REBOL_OPERATOR 4 #define SCE_REBOL_CHARACTER 5 #define SCE_REBOL_QUOTEDSTRING 6 #define SCE_REBOL_BRACEDSTRING 7 #define SCE_REBOL_NUMBER 8 #define SCE_REBOL_PAIR 9 #define SCE_REBOL_TUPLE 10 #define SCE_REBOL_BINARY 11 #define SCE_REBOL_MONEY 12 #define SCE_REBOL_ISSUE 13 #define SCE_REBOL_TAG 14 #define SCE_REBOL_FILE 15 #define SCE_REBOL_EMAIL 16 #define SCE_REBOL_URL 17 #define SCE_REBOL_DATE 18 #define SCE_REBOL_TIME 19 #define SCE_REBOL_IDENTIFIER 20 #define SCE_REBOL_WORD 21 #define SCE_REBOL_WORD2 22 #define SCE_REBOL_WORD3 23 #define SCE_REBOL_WORD4 24 #define SCE_REBOL_WORD5 25 #define SCE_REBOL_WORD6 26 #define SCE_REBOL_WORD7 27 #define SCE_REBOL_WORD8 28 #define SCE_SQL_DEFAULT 0 #define SCE_SQL_COMMENT 1 #define SCE_SQL_COMMENTLINE 2 #define SCE_SQL_COMMENTDOC 3 #define SCE_SQL_NUMBER 4 #define SCE_SQL_WORD 5 #define SCE_SQL_STRING 6 #define SCE_SQL_CHARACTER 7 #define SCE_SQL_SQLPLUS 8 #define SCE_SQL_SQLPLUS_PROMPT 9 #define SCE_SQL_OPERATOR 10 #define SCE_SQL_IDENTIFIER 11 #define SCE_SQL_SQLPLUS_COMMENT 13 #define SCE_SQL_COMMENTLINEDOC 15 #define SCE_SQL_WORD2 16 #define SCE_SQL_COMMENTDOCKEYWORD 17 #define SCE_SQL_COMMENTDOCKEYWORDERROR 18 #define SCE_SQL_USER1 19 #define SCE_SQL_USER2 20 #define SCE_SQL_USER3 21 #define SCE_SQL_USER4 22 #define SCE_SQL_QUOTEDIDENTIFIER 23 #define SCE_SQL_QOPERATOR 24 #define SCE_ST_DEFAULT 0 #define SCE_ST_STRING 1 #define SCE_ST_NUMBER 2 #define SCE_ST_COMMENT 3 #define SCE_ST_SYMBOL 4 #define SCE_ST_BINARY 5 #define SCE_ST_BOOL 6 #define SCE_ST_SELF 7 #define SCE_ST_SUPER 8 #define SCE_ST_NIL 9 #define SCE_ST_GLOBAL 10 #define SCE_ST_RETURN 11 #define SCE_ST_SPECIAL 12 #define SCE_ST_KWSEND 13 #define SCE_ST_ASSIGN 14 #define SCE_ST_CHARACTER 15 #define SCE_ST_SPEC_SEL 16 #define SCE_FS_DEFAULT 0 #define SCE_FS_COMMENT 1 #define SCE_FS_COMMENTLINE 2 #define SCE_FS_COMMENTDOC 3 #define SCE_FS_COMMENTLINEDOC 4 #define SCE_FS_COMMENTDOCKEYWORD 5 #define SCE_FS_COMMENTDOCKEYWORDERROR 6 #define SCE_FS_KEYWORD 7 #define SCE_FS_KEYWORD2 8 #define SCE_FS_KEYWORD3 9 #define SCE_FS_KEYWORD4 10 #define SCE_FS_NUMBER 11 #define SCE_FS_STRING 12 #define SCE_FS_PREPROCESSOR 13 #define SCE_FS_OPERATOR 14 #define SCE_FS_IDENTIFIER 15 #define SCE_FS_DATE 16 #define SCE_FS_STRINGEOL 17 #define SCE_FS_CONSTANT 18 #define SCE_FS_WORDOPERATOR 19 #define SCE_FS_DISABLEDCODE 20 #define SCE_FS_DEFAULT_C 21 #define SCE_FS_COMMENTDOC_C 22 #define SCE_FS_COMMENTLINEDOC_C 23 #define SCE_FS_KEYWORD_C 24 #define SCE_FS_KEYWORD2_C 25 #define SCE_FS_NUMBER_C 26 #define SCE_FS_STRING_C 27 #define SCE_FS_PREPROCESSOR_C 28 #define SCE_FS_OPERATOR_C 29 #define SCE_FS_IDENTIFIER_C 30 #define SCE_FS_STRINGEOL_C 31 #define SCE_CSOUND_DEFAULT 0 #define SCE_CSOUND_COMMENT 1 #define SCE_CSOUND_NUMBER 2 #define SCE_CSOUND_OPERATOR 3 #define SCE_CSOUND_INSTR 4 #define SCE_CSOUND_IDENTIFIER 5 #define SCE_CSOUND_OPCODE 6 #define SCE_CSOUND_HEADERSTMT 7 #define SCE_CSOUND_USERKEYWORD 8 #define SCE_CSOUND_COMMENTBLOCK 9 #define SCE_CSOUND_PARAM 10 #define SCE_CSOUND_ARATE_VAR 11 #define SCE_CSOUND_KRATE_VAR 12 #define SCE_CSOUND_IRATE_VAR 13 #define SCE_CSOUND_GLOBAL_VAR 14 #define SCE_CSOUND_STRINGEOL 15 #define SCE_INNO_DEFAULT 0 #define SCE_INNO_COMMENT 1 #define SCE_INNO_KEYWORD 2 #define SCE_INNO_PARAMETER 3 #define SCE_INNO_SECTION 4 #define SCE_INNO_PREPROC 5 #define SCE_INNO_INLINE_EXPANSION 6 #define SCE_INNO_COMMENT_PASCAL 7 #define SCE_INNO_KEYWORD_PASCAL 8 #define SCE_INNO_KEYWORD_USER 9 #define SCE_INNO_STRING_DOUBLE 10 #define SCE_INNO_STRING_SINGLE 11 #define SCE_INNO_IDENTIFIER 12 #define SCE_OPAL_SPACE 0 #define SCE_OPAL_COMMENT_BLOCK 1 #define SCE_OPAL_COMMENT_LINE 2 #define SCE_OPAL_INTEGER 3 #define SCE_OPAL_KEYWORD 4 #define SCE_OPAL_SORT 5 #define SCE_OPAL_STRING 6 #define SCE_OPAL_PAR 7 #define SCE_OPAL_BOOL_CONST 8 #define SCE_OPAL_DEFAULT 32 #define SCE_SPICE_DEFAULT 0 #define SCE_SPICE_IDENTIFIER 1 #define SCE_SPICE_KEYWORD 2 #define SCE_SPICE_KEYWORD2 3 #define SCE_SPICE_KEYWORD3 4 #define SCE_SPICE_NUMBER 5 #define SCE_SPICE_DELIMITER 6 #define SCE_SPICE_VALUE 7 #define SCE_SPICE_COMMENTLINE 8 #define SCE_CMAKE_DEFAULT 0 #define SCE_CMAKE_COMMENT 1 #define SCE_CMAKE_STRINGDQ 2 #define SCE_CMAKE_STRINGLQ 3 #define SCE_CMAKE_STRINGRQ 4 #define SCE_CMAKE_COMMANDS 5 #define SCE_CMAKE_PARAMETERS 6 #define SCE_CMAKE_VARIABLE 7 #define SCE_CMAKE_USERDEFINED 8 #define SCE_CMAKE_WHILEDEF 9 #define SCE_CMAKE_FOREACHDEF 10 #define SCE_CMAKE_IFDEFINEDEF 11 #define SCE_CMAKE_MACRODEF 12 #define SCE_CMAKE_STRINGVAR 13 #define SCE_CMAKE_NUMBER 14 #define SCE_GAP_DEFAULT 0 #define SCE_GAP_IDENTIFIER 1 #define SCE_GAP_KEYWORD 2 #define SCE_GAP_KEYWORD2 3 #define SCE_GAP_KEYWORD3 4 #define SCE_GAP_KEYWORD4 5 #define SCE_GAP_STRING 6 #define SCE_GAP_CHAR 7 #define SCE_GAP_OPERATOR 8 #define SCE_GAP_COMMENT 9 #define SCE_GAP_NUMBER 10 #define SCE_GAP_STRINGEOL 11 #define SCE_PLM_DEFAULT 0 #define SCE_PLM_COMMENT 1 #define SCE_PLM_STRING 2 #define SCE_PLM_NUMBER 3 #define SCE_PLM_IDENTIFIER 4 #define SCE_PLM_OPERATOR 5 #define SCE_PLM_CONTROL 6 #define SCE_PLM_KEYWORD 7 #define SCE_ABL_DEFAULT 0 #define SCE_ABL_NUMBER 1 #define SCE_ABL_WORD 2 #define SCE_ABL_STRING 3 #define SCE_ABL_CHARACTER 4 #define SCE_ABL_PREPROCESSOR 5 #define SCE_ABL_OPERATOR 6 #define SCE_ABL_IDENTIFIER 7 #define SCE_ABL_BLOCK 8 #define SCE_ABL_END 9 #define SCE_ABL_COMMENT 10 #define SCE_ABL_TASKMARKER 11 #define SCE_ABL_LINECOMMENT 12 #define SCE_ABAQUS_DEFAULT 0 #define SCE_ABAQUS_COMMENT 1 #define SCE_ABAQUS_COMMENTBLOCK 2 #define SCE_ABAQUS_NUMBER 3 #define SCE_ABAQUS_STRING 4 #define SCE_ABAQUS_OPERATOR 5 #define SCE_ABAQUS_WORD 6 #define SCE_ABAQUS_PROCESSOR 7 #define SCE_ABAQUS_COMMAND 8 #define SCE_ABAQUS_SLASHCOMMAND 9 #define SCE_ABAQUS_STARCOMMAND 10 #define SCE_ABAQUS_ARGUMENT 11 #define SCE_ABAQUS_FUNCTION 12 #define SCE_ASY_DEFAULT 0 #define SCE_ASY_COMMENT 1 #define SCE_ASY_COMMENTLINE 2 #define SCE_ASY_NUMBER 3 #define SCE_ASY_WORD 4 #define SCE_ASY_STRING 5 #define SCE_ASY_CHARACTER 6 #define SCE_ASY_OPERATOR 7 #define SCE_ASY_IDENTIFIER 8 #define SCE_ASY_STRINGEOL 9 #define SCE_ASY_COMMENTLINEDOC 10 #define SCE_ASY_WORD2 11 #define SCE_R_DEFAULT 0 #define SCE_R_COMMENT 1 #define SCE_R_KWORD 2 #define SCE_R_BASEKWORD 3 #define SCE_R_OTHERKWORD 4 #define SCE_R_NUMBER 5 #define SCE_R_STRING 6 #define SCE_R_STRING2 7 #define SCE_R_OPERATOR 8 #define SCE_R_IDENTIFIER 9 #define SCE_R_INFIX 10 #define SCE_R_INFIXEOL 11 #define SCE_R_BACKTICKS 12 #define SCE_R_RAWSTRING 13 #define SCE_R_RAWSTRING2 14 #define SCE_R_ESCAPESEQUENCE 15 #define SCE_MAGIK_DEFAULT 0 #define SCE_MAGIK_COMMENT 1 #define SCE_MAGIK_HYPER_COMMENT 16 #define SCE_MAGIK_STRING 2 #define SCE_MAGIK_CHARACTER 3 #define SCE_MAGIK_NUMBER 4 #define SCE_MAGIK_IDENTIFIER 5 #define SCE_MAGIK_OPERATOR 6 #define SCE_MAGIK_FLOW 7 #define SCE_MAGIK_CONTAINER 8 #define SCE_MAGIK_BRACKET_BLOCK 9 #define SCE_MAGIK_BRACE_BLOCK 10 #define SCE_MAGIK_SQBRACKET_BLOCK 11 #define SCE_MAGIK_UNKNOWN_KEYWORD 12 #define SCE_MAGIK_KEYWORD 13 #define SCE_MAGIK_PRAGMA 14 #define SCE_MAGIK_SYMBOL 15 #define SCE_POWERSHELL_DEFAULT 0 #define SCE_POWERSHELL_COMMENT 1 #define SCE_POWERSHELL_STRING 2 #define SCE_POWERSHELL_CHARACTER 3 #define SCE_POWERSHELL_NUMBER 4 #define SCE_POWERSHELL_VARIABLE 5 #define SCE_POWERSHELL_OPERATOR 6 #define SCE_POWERSHELL_IDENTIFIER 7 #define SCE_POWERSHELL_KEYWORD 8 #define SCE_POWERSHELL_CMDLET 9 #define SCE_POWERSHELL_ALIAS 10 #define SCE_POWERSHELL_FUNCTION 11 #define SCE_POWERSHELL_USER1 12 #define SCE_POWERSHELL_COMMENTSTREAM 13 #define SCE_POWERSHELL_HERE_STRING 14 #define SCE_POWERSHELL_HERE_CHARACTER 15 #define SCE_POWERSHELL_COMMENTDOCKEYWORD 16 #define SCE_MYSQL_DEFAULT 0 #define SCE_MYSQL_COMMENT 1 #define SCE_MYSQL_COMMENTLINE 2 #define SCE_MYSQL_VARIABLE 3 #define SCE_MYSQL_SYSTEMVARIABLE 4 #define SCE_MYSQL_KNOWNSYSTEMVARIABLE 5 #define SCE_MYSQL_NUMBER 6 #define SCE_MYSQL_MAJORKEYWORD 7 #define SCE_MYSQL_KEYWORD 8 #define SCE_MYSQL_DATABASEOBJECT 9 #define SCE_MYSQL_PROCEDUREKEYWORD 10 #define SCE_MYSQL_STRING 11 #define SCE_MYSQL_SQSTRING 12 #define SCE_MYSQL_DQSTRING 13 #define SCE_MYSQL_OPERATOR 14 #define SCE_MYSQL_FUNCTION 15 #define SCE_MYSQL_IDENTIFIER 16 #define SCE_MYSQL_QUOTEDIDENTIFIER 17 #define SCE_MYSQL_USER1 18 #define SCE_MYSQL_USER2 19 #define SCE_MYSQL_USER3 20 #define SCE_MYSQL_HIDDENCOMMAND 21 #define SCE_MYSQL_PLACEHOLDER 22 #define SCE_PO_DEFAULT 0 #define SCE_PO_COMMENT 1 #define SCE_PO_MSGID 2 #define SCE_PO_MSGID_TEXT 3 #define SCE_PO_MSGSTR 4 #define SCE_PO_MSGSTR_TEXT 5 #define SCE_PO_MSGCTXT 6 #define SCE_PO_MSGCTXT_TEXT 7 #define SCE_PO_FUZZY 8 #define SCE_PO_PROGRAMMER_COMMENT 9 #define SCE_PO_REFERENCE 10 #define SCE_PO_FLAGS 11 #define SCE_PO_MSGID_TEXT_EOL 12 #define SCE_PO_MSGSTR_TEXT_EOL 13 #define SCE_PO_MSGCTXT_TEXT_EOL 14 #define SCE_PO_ERROR 15 #define SCE_PAS_DEFAULT 0 #define SCE_PAS_IDENTIFIER 1 #define SCE_PAS_COMMENT 2 #define SCE_PAS_COMMENT2 3 #define SCE_PAS_COMMENTLINE 4 #define SCE_PAS_PREPROCESSOR 5 #define SCE_PAS_PREPROCESSOR2 6 #define SCE_PAS_NUMBER 7 #define SCE_PAS_HEXNUMBER 8 #define SCE_PAS_WORD 9 #define SCE_PAS_STRING 10 #define SCE_PAS_STRINGEOL 11 #define SCE_PAS_CHARACTER 12 #define SCE_PAS_OPERATOR 13 #define SCE_PAS_ASM 14 #define SCE_SORCUS_DEFAULT 0 #define SCE_SORCUS_COMMAND 1 #define SCE_SORCUS_PARAMETER 2 #define SCE_SORCUS_COMMENTLINE 3 #define SCE_SORCUS_STRING 4 #define SCE_SORCUS_STRINGEOL 5 #define SCE_SORCUS_IDENTIFIER 6 #define SCE_SORCUS_OPERATOR 7 #define SCE_SORCUS_NUMBER 8 #define SCE_SORCUS_CONSTANT 9 #define SCE_POWERPRO_DEFAULT 0 #define SCE_POWERPRO_COMMENTBLOCK 1 #define SCE_POWERPRO_COMMENTLINE 2 #define SCE_POWERPRO_NUMBER 3 #define SCE_POWERPRO_WORD 4 #define SCE_POWERPRO_WORD2 5 #define SCE_POWERPRO_WORD3 6 #define SCE_POWERPRO_WORD4 7 #define SCE_POWERPRO_DOUBLEQUOTEDSTRING 8 #define SCE_POWERPRO_SINGLEQUOTEDSTRING 9 #define SCE_POWERPRO_LINECONTINUE 10 #define SCE_POWERPRO_OPERATOR 11 #define SCE_POWERPRO_IDENTIFIER 12 #define SCE_POWERPRO_STRINGEOL 13 #define SCE_POWERPRO_VERBATIM 14 #define SCE_POWERPRO_ALTQUOTE 15 #define SCE_POWERPRO_FUNCTION 16 #define SCE_SML_DEFAULT 0 #define SCE_SML_IDENTIFIER 1 #define SCE_SML_TAGNAME 2 #define SCE_SML_KEYWORD 3 #define SCE_SML_KEYWORD2 4 #define SCE_SML_KEYWORD3 5 #define SCE_SML_LINENUM 6 #define SCE_SML_OPERATOR 7 #define SCE_SML_NUMBER 8 #define SCE_SML_CHAR 9 #define SCE_SML_STRING 11 #define SCE_SML_COMMENT 12 #define SCE_SML_COMMENT1 13 #define SCE_SML_COMMENT2 14 #define SCE_SML_COMMENT3 15 #define SCE_MARKDOWN_DEFAULT 0 #define SCE_MARKDOWN_LINE_BEGIN 1 #define SCE_MARKDOWN_STRONG1 2 #define SCE_MARKDOWN_STRONG2 3 #define SCE_MARKDOWN_EM1 4 #define SCE_MARKDOWN_EM2 5 #define SCE_MARKDOWN_HEADER1 6 #define SCE_MARKDOWN_HEADER2 7 #define SCE_MARKDOWN_HEADER3 8 #define SCE_MARKDOWN_HEADER4 9 #define SCE_MARKDOWN_HEADER5 10 #define SCE_MARKDOWN_HEADER6 11 #define SCE_MARKDOWN_PRECHAR 12 #define SCE_MARKDOWN_ULIST_ITEM 13 #define SCE_MARKDOWN_OLIST_ITEM 14 #define SCE_MARKDOWN_BLOCKQUOTE 15 #define SCE_MARKDOWN_STRIKEOUT 16 #define SCE_MARKDOWN_HRULE 17 #define SCE_MARKDOWN_LINK 18 #define SCE_MARKDOWN_CODE 19 #define SCE_MARKDOWN_CODE2 20 #define SCE_MARKDOWN_CODEBK 21 #define SCE_TXT2TAGS_DEFAULT 0 #define SCE_TXT2TAGS_LINE_BEGIN 1 #define SCE_TXT2TAGS_STRONG1 2 #define SCE_TXT2TAGS_STRONG2 3 #define SCE_TXT2TAGS_EM1 4 #define SCE_TXT2TAGS_EM2 5 #define SCE_TXT2TAGS_HEADER1 6 #define SCE_TXT2TAGS_HEADER2 7 #define SCE_TXT2TAGS_HEADER3 8 #define SCE_TXT2TAGS_HEADER4 9 #define SCE_TXT2TAGS_HEADER5 10 #define SCE_TXT2TAGS_HEADER6 11 #define SCE_TXT2TAGS_PRECHAR 12 #define SCE_TXT2TAGS_ULIST_ITEM 13 #define SCE_TXT2TAGS_OLIST_ITEM 14 #define SCE_TXT2TAGS_BLOCKQUOTE 15 #define SCE_TXT2TAGS_STRIKEOUT 16 #define SCE_TXT2TAGS_HRULE 17 #define SCE_TXT2TAGS_LINK 18 #define SCE_TXT2TAGS_CODE 19 #define SCE_TXT2TAGS_CODE2 20 #define SCE_TXT2TAGS_CODEBK 21 #define SCE_TXT2TAGS_COMMENT 22 #define SCE_TXT2TAGS_OPTION 23 #define SCE_TXT2TAGS_PREPROC 24 #define SCE_TXT2TAGS_POSTPROC 25 #define SCE_A68K_DEFAULT 0 #define SCE_A68K_COMMENT 1 #define SCE_A68K_NUMBER_DEC 2 #define SCE_A68K_NUMBER_BIN 3 #define SCE_A68K_NUMBER_HEX 4 #define SCE_A68K_STRING1 5 #define SCE_A68K_OPERATOR 6 #define SCE_A68K_CPUINSTRUCTION 7 #define SCE_A68K_EXTINSTRUCTION 8 #define SCE_A68K_REGISTER 9 #define SCE_A68K_DIRECTIVE 10 #define SCE_A68K_MACRO_ARG 11 #define SCE_A68K_LABEL 12 #define SCE_A68K_STRING2 13 #define SCE_A68K_IDENTIFIER 14 #define SCE_A68K_MACRO_DECLARATION 15 #define SCE_A68K_COMMENT_WORD 16 #define SCE_A68K_COMMENT_SPECIAL 17 #define SCE_A68K_COMMENT_DOXYGEN 18 #define SCE_MODULA_DEFAULT 0 #define SCE_MODULA_COMMENT 1 #define SCE_MODULA_DOXYCOMM 2 #define SCE_MODULA_DOXYKEY 3 #define SCE_MODULA_KEYWORD 4 #define SCE_MODULA_RESERVED 5 #define SCE_MODULA_NUMBER 6 #define SCE_MODULA_BASENUM 7 #define SCE_MODULA_FLOAT 8 #define SCE_MODULA_STRING 9 #define SCE_MODULA_STRSPEC 10 #define SCE_MODULA_CHAR 11 #define SCE_MODULA_CHARSPEC 12 #define SCE_MODULA_PROC 13 #define SCE_MODULA_PRAGMA 14 #define SCE_MODULA_PRGKEY 15 #define SCE_MODULA_OPERATOR 16 #define SCE_MODULA_BADSTR 17 #define SCE_COFFEESCRIPT_DEFAULT 0 #define SCE_COFFEESCRIPT_COMMENT 1 #define SCE_COFFEESCRIPT_COMMENTLINE 2 #define SCE_COFFEESCRIPT_COMMENTDOC 3 #define SCE_COFFEESCRIPT_NUMBER 4 #define SCE_COFFEESCRIPT_WORD 5 #define SCE_COFFEESCRIPT_STRING 6 #define SCE_COFFEESCRIPT_CHARACTER 7 #define SCE_COFFEESCRIPT_UUID 8 #define SCE_COFFEESCRIPT_PREPROCESSOR 9 #define SCE_COFFEESCRIPT_OPERATOR 10 #define SCE_COFFEESCRIPT_IDENTIFIER 11 #define SCE_COFFEESCRIPT_STRINGEOL 12 #define SCE_COFFEESCRIPT_VERBATIM 13 #define SCE_COFFEESCRIPT_REGEX 14 #define SCE_COFFEESCRIPT_COMMENTLINEDOC 15 #define SCE_COFFEESCRIPT_WORD2 16 #define SCE_COFFEESCRIPT_COMMENTDOCKEYWORD 17 #define SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR 18 #define SCE_COFFEESCRIPT_GLOBALCLASS 19 #define SCE_COFFEESCRIPT_STRINGRAW 20 #define SCE_COFFEESCRIPT_TRIPLEVERBATIM 21 #define SCE_COFFEESCRIPT_COMMENTBLOCK 22 #define SCE_COFFEESCRIPT_VERBOSE_REGEX 23 #define SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT 24 #define SCE_COFFEESCRIPT_INSTANCEPROPERTY 25 #define SCE_AVS_DEFAULT 0 #define SCE_AVS_COMMENTBLOCK 1 #define SCE_AVS_COMMENTBLOCKN 2 #define SCE_AVS_COMMENTLINE 3 #define SCE_AVS_NUMBER 4 #define SCE_AVS_OPERATOR 5 #define SCE_AVS_IDENTIFIER 6 #define SCE_AVS_STRING 7 #define SCE_AVS_TRIPLESTRING 8 #define SCE_AVS_KEYWORD 9 #define SCE_AVS_FILTER 10 #define SCE_AVS_PLUGIN 11 #define SCE_AVS_FUNCTION 12 #define SCE_AVS_CLIPPROP 13 #define SCE_AVS_USERDFN 14 #define SCE_ECL_DEFAULT 0 #define SCE_ECL_COMMENT 1 #define SCE_ECL_COMMENTLINE 2 #define SCE_ECL_NUMBER 3 #define SCE_ECL_STRING 4 #define SCE_ECL_WORD0 5 #define SCE_ECL_OPERATOR 6 #define SCE_ECL_CHARACTER 7 #define SCE_ECL_UUID 8 #define SCE_ECL_PREPROCESSOR 9 #define SCE_ECL_UNKNOWN 10 #define SCE_ECL_IDENTIFIER 11 #define SCE_ECL_STRINGEOL 12 #define SCE_ECL_VERBATIM 13 #define SCE_ECL_REGEX 14 #define SCE_ECL_COMMENTLINEDOC 15 #define SCE_ECL_WORD1 16 #define SCE_ECL_COMMENTDOCKEYWORD 17 #define SCE_ECL_COMMENTDOCKEYWORDERROR 18 #define SCE_ECL_WORD2 19 #define SCE_ECL_WORD3 20 #define SCE_ECL_WORD4 21 #define SCE_ECL_WORD5 22 #define SCE_ECL_COMMENTDOC 23 #define SCE_ECL_ADDED 24 #define SCE_ECL_DELETED 25 #define SCE_ECL_CHANGED 26 #define SCE_ECL_MOVED 27 #define SCE_OSCRIPT_DEFAULT 0 #define SCE_OSCRIPT_LINE_COMMENT 1 #define SCE_OSCRIPT_BLOCK_COMMENT 2 #define SCE_OSCRIPT_DOC_COMMENT 3 #define SCE_OSCRIPT_PREPROCESSOR 4 #define SCE_OSCRIPT_NUMBER 5 #define SCE_OSCRIPT_SINGLEQUOTE_STRING 6 #define SCE_OSCRIPT_DOUBLEQUOTE_STRING 7 #define SCE_OSCRIPT_CONSTANT 8 #define SCE_OSCRIPT_IDENTIFIER 9 #define SCE_OSCRIPT_GLOBAL 10 #define SCE_OSCRIPT_KEYWORD 11 #define SCE_OSCRIPT_OPERATOR 12 #define SCE_OSCRIPT_LABEL 13 #define SCE_OSCRIPT_TYPE 14 #define SCE_OSCRIPT_FUNCTION 15 #define SCE_OSCRIPT_OBJECT 16 #define SCE_OSCRIPT_PROPERTY 17 #define SCE_OSCRIPT_METHOD 18 #define SCE_VISUALPROLOG_DEFAULT 0 #define SCE_VISUALPROLOG_KEY_MAJOR 1 #define SCE_VISUALPROLOG_KEY_MINOR 2 #define SCE_VISUALPROLOG_KEY_DIRECTIVE 3 #define SCE_VISUALPROLOG_COMMENT_BLOCK 4 #define SCE_VISUALPROLOG_COMMENT_LINE 5 #define SCE_VISUALPROLOG_COMMENT_KEY 6 #define SCE_VISUALPROLOG_COMMENT_KEY_ERROR 7 #define SCE_VISUALPROLOG_IDENTIFIER 8 #define SCE_VISUALPROLOG_VARIABLE 9 #define SCE_VISUALPROLOG_ANONYMOUS 10 #define SCE_VISUALPROLOG_NUMBER 11 #define SCE_VISUALPROLOG_OPERATOR 12 #define SCE_VISUALPROLOG_UNUSED1 13 #define SCE_VISUALPROLOG_UNUSED2 14 #define SCE_VISUALPROLOG_UNUSED3 15 #define SCE_VISUALPROLOG_STRING_QUOTE 16 #define SCE_VISUALPROLOG_STRING_ESCAPE 17 #define SCE_VISUALPROLOG_STRING_ESCAPE_ERROR 18 #define SCE_VISUALPROLOG_UNUSED4 19 #define SCE_VISUALPROLOG_STRING 20 #define SCE_VISUALPROLOG_UNUSED5 21 #define SCE_VISUALPROLOG_STRING_EOL 22 #define SCE_VISUALPROLOG_EMBEDDED 23 #define SCE_VISUALPROLOG_PLACEHOLDER 24 #define SCE_STTXT_DEFAULT 0 #define SCE_STTXT_COMMENT 1 #define SCE_STTXT_COMMENTLINE 2 #define SCE_STTXT_KEYWORD 3 #define SCE_STTXT_TYPE 4 #define SCE_STTXT_FUNCTION 5 #define SCE_STTXT_FB 6 #define SCE_STTXT_NUMBER 7 #define SCE_STTXT_HEXNUMBER 8 #define SCE_STTXT_PRAGMA 9 #define SCE_STTXT_OPERATOR 10 #define SCE_STTXT_CHARACTER 11 #define SCE_STTXT_STRING1 12 #define SCE_STTXT_STRING2 13 #define SCE_STTXT_STRINGEOL 14 #define SCE_STTXT_IDENTIFIER 15 #define SCE_STTXT_DATETIME 16 #define SCE_STTXT_VARS 17 #define SCE_STTXT_PRAGMAS 18 #define SCE_KVIRC_DEFAULT 0 #define SCE_KVIRC_COMMENT 1 #define SCE_KVIRC_COMMENTBLOCK 2 #define SCE_KVIRC_STRING 3 #define SCE_KVIRC_WORD 4 #define SCE_KVIRC_KEYWORD 5 #define SCE_KVIRC_FUNCTION_KEYWORD 6 #define SCE_KVIRC_FUNCTION 7 #define SCE_KVIRC_VARIABLE 8 #define SCE_KVIRC_NUMBER 9 #define SCE_KVIRC_OPERATOR 10 #define SCE_KVIRC_STRING_FUNCTION 11 #define SCE_KVIRC_STRING_VARIABLE 12 #define SCE_RUST_DEFAULT 0 #define SCE_RUST_COMMENTBLOCK 1 #define SCE_RUST_COMMENTLINE 2 #define SCE_RUST_COMMENTBLOCKDOC 3 #define SCE_RUST_COMMENTLINEDOC 4 #define SCE_RUST_NUMBER 5 #define SCE_RUST_WORD 6 #define SCE_RUST_WORD2 7 #define SCE_RUST_WORD3 8 #define SCE_RUST_WORD4 9 #define SCE_RUST_WORD5 10 #define SCE_RUST_WORD6 11 #define SCE_RUST_WORD7 12 #define SCE_RUST_STRING 13 #define SCE_RUST_STRINGR 14 #define SCE_RUST_CHARACTER 15 #define SCE_RUST_OPERATOR 16 #define SCE_RUST_IDENTIFIER 17 #define SCE_RUST_LIFETIME 18 #define SCE_RUST_MACRO 19 #define SCE_RUST_LEXERROR 20 #define SCE_RUST_BYTESTRING 21 #define SCE_RUST_BYTESTRINGR 22 #define SCE_RUST_BYTECHARACTER 23 #define SCE_RUST_CSTRING 24 #define SCE_RUST_CSTRINGR 25 #define SCE_DMAP_DEFAULT 0 #define SCE_DMAP_COMMENT 1 #define SCE_DMAP_NUMBER 2 #define SCE_DMAP_STRING1 3 #define SCE_DMAP_STRING2 4 #define SCE_DMAP_STRINGEOL 5 #define SCE_DMAP_OPERATOR 6 #define SCE_DMAP_IDENTIFIER 7 #define SCE_DMAP_WORD 8 #define SCE_DMAP_WORD2 9 #define SCE_DMAP_WORD3 10 #define SCE_DMIS_DEFAULT 0 #define SCE_DMIS_COMMENT 1 #define SCE_DMIS_STRING 2 #define SCE_DMIS_NUMBER 3 #define SCE_DMIS_KEYWORD 4 #define SCE_DMIS_MAJORWORD 5 #define SCE_DMIS_MINORWORD 6 #define SCE_DMIS_UNSUPPORTED_MAJOR 7 #define SCE_DMIS_UNSUPPORTED_MINOR 8 #define SCE_DMIS_LABEL 9 #define SCE_REG_DEFAULT 0 #define SCE_REG_COMMENT 1 #define SCE_REG_VALUENAME 2 #define SCE_REG_STRING 3 #define SCE_REG_HEXDIGIT 4 #define SCE_REG_VALUETYPE 5 #define SCE_REG_ADDEDKEY 6 #define SCE_REG_DELETEDKEY 7 #define SCE_REG_ESCAPED 8 #define SCE_REG_KEYPATH_GUID 9 #define SCE_REG_STRING_GUID 10 #define SCE_REG_PARAMETER 11 #define SCE_REG_OPERATOR 12 #define SCE_BIBTEX_DEFAULT 0 #define SCE_BIBTEX_ENTRY 1 #define SCE_BIBTEX_UNKNOWN_ENTRY 2 #define SCE_BIBTEX_KEY 3 #define SCE_BIBTEX_PARAMETER 4 #define SCE_BIBTEX_VALUE 5 #define SCE_BIBTEX_COMMENT 6 #define SCE_HEX_DEFAULT 0 #define SCE_HEX_RECSTART 1 #define SCE_HEX_RECTYPE 2 #define SCE_HEX_RECTYPE_UNKNOWN 3 #define SCE_HEX_BYTECOUNT 4 #define SCE_HEX_BYTECOUNT_WRONG 5 #define SCE_HEX_NOADDRESS 6 #define SCE_HEX_DATAADDRESS 7 #define SCE_HEX_RECCOUNT 8 #define SCE_HEX_STARTADDRESS 9 #define SCE_HEX_ADDRESSFIELD_UNKNOWN 10 #define SCE_HEX_EXTENDEDADDRESS 11 #define SCE_HEX_DATA_ODD 12 #define SCE_HEX_DATA_EVEN 13 #define SCE_HEX_DATA_UNKNOWN 14 #define SCE_HEX_DATA_EMPTY 15 #define SCE_HEX_CHECKSUM 16 #define SCE_HEX_CHECKSUM_WRONG 17 #define SCE_HEX_GARBAGE 18 #define SCE_JSON_DEFAULT 0 #define SCE_JSON_NUMBER 1 #define SCE_JSON_STRING 2 #define SCE_JSON_STRINGEOL 3 #define SCE_JSON_PROPERTYNAME 4 #define SCE_JSON_ESCAPESEQUENCE 5 #define SCE_JSON_LINECOMMENT 6 #define SCE_JSON_BLOCKCOMMENT 7 #define SCE_JSON_OPERATOR 8 #define SCE_JSON_URI 9 #define SCE_JSON_COMPACTIRI 10 #define SCE_JSON_KEYWORD 11 #define SCE_JSON_LDKEYWORD 12 #define SCE_JSON_ERROR 13 #define SCE_EDI_DEFAULT 0 #define SCE_EDI_SEGMENTSTART 1 #define SCE_EDI_SEGMENTEND 2 #define SCE_EDI_SEP_ELEMENT 3 #define SCE_EDI_SEP_COMPOSITE 4 #define SCE_EDI_SEP_RELEASE 5 #define SCE_EDI_UNA 6 #define SCE_EDI_UNH 7 #define SCE_EDI_BADSEGMENT 8 #define SCE_STATA_DEFAULT 0 #define SCE_STATA_COMMENT 1 #define SCE_STATA_COMMENTLINE 2 #define SCE_STATA_COMMENTBLOCK 3 #define SCE_STATA_NUMBER 4 #define SCE_STATA_OPERATOR 5 #define SCE_STATA_IDENTIFIER 6 #define SCE_STATA_STRING 7 #define SCE_STATA_TYPE 8 #define SCE_STATA_WORD 9 #define SCE_STATA_GLOBAL_MACRO 10 #define SCE_STATA_MACRO 11 #define SCE_SAS_DEFAULT 0 #define SCE_SAS_COMMENT 1 #define SCE_SAS_COMMENTLINE 2 #define SCE_SAS_COMMENTBLOCK 3 #define SCE_SAS_NUMBER 4 #define SCE_SAS_OPERATOR 5 #define SCE_SAS_IDENTIFIER 6 #define SCE_SAS_STRING 7 #define SCE_SAS_TYPE 8 #define SCE_SAS_WORD 9 #define SCE_SAS_GLOBAL_MACRO 10 #define SCE_SAS_MACRO 11 #define SCE_SAS_MACRO_KEYWORD 12 #define SCE_SAS_BLOCK_KEYWORD 13 #define SCE_SAS_MACRO_FUNCTION 14 #define SCE_SAS_STATEMENT 15 #define SCE_NIM_DEFAULT 0 #define SCE_NIM_COMMENT 1 #define SCE_NIM_COMMENTDOC 2 #define SCE_NIM_COMMENTLINE 3 #define SCE_NIM_COMMENTLINEDOC 4 #define SCE_NIM_NUMBER 5 #define SCE_NIM_STRING 6 #define SCE_NIM_CHARACTER 7 #define SCE_NIM_WORD 8 #define SCE_NIM_TRIPLE 9 #define SCE_NIM_TRIPLEDOUBLE 10 #define SCE_NIM_BACKTICKS 11 #define SCE_NIM_FUNCNAME 12 #define SCE_NIM_STRINGEOL 13 #define SCE_NIM_NUMERROR 14 #define SCE_NIM_OPERATOR 15 #define SCE_NIM_IDENTIFIER 16 #define SCE_CIL_DEFAULT 0 #define SCE_CIL_COMMENT 1 #define SCE_CIL_COMMENTLINE 2 #define SCE_CIL_WORD 3 #define SCE_CIL_WORD2 4 #define SCE_CIL_WORD3 5 #define SCE_CIL_STRING 6 #define SCE_CIL_LABEL 7 #define SCE_CIL_OPERATOR 8 #define SCE_CIL_IDENTIFIER 9 #define SCE_CIL_STRINGEOL 10 #define SCE_X12_DEFAULT 0 #define SCE_X12_BAD 1 #define SCE_X12_ENVELOPE 2 #define SCE_X12_FUNCTIONGROUP 3 #define SCE_X12_TRANSACTIONSET 4 #define SCE_X12_SEGMENTHEADER 5 #define SCE_X12_SEGMENTEND 6 #define SCE_X12_SEP_ELEMENT 7 #define SCE_X12_SEP_SUBELEMENT 8 #define SCE_DF_DEFAULT 0 #define SCE_DF_IDENTIFIER 1 #define SCE_DF_METATAG 2 #define SCE_DF_IMAGE 3 #define SCE_DF_COMMENTLINE 4 #define SCE_DF_PREPROCESSOR 5 #define SCE_DF_PREPROCESSOR2 6 #define SCE_DF_NUMBER 7 #define SCE_DF_HEXNUMBER 8 #define SCE_DF_WORD 9 #define SCE_DF_STRING 10 #define SCE_DF_STRINGEOL 11 #define SCE_DF_SCOPEWORD 12 #define SCE_DF_OPERATOR 13 #define SCE_DF_ICODE 14 #define SCE_HOLLYWOOD_DEFAULT 0 #define SCE_HOLLYWOOD_COMMENT 1 #define SCE_HOLLYWOOD_COMMENTBLOCK 2 #define SCE_HOLLYWOOD_NUMBER 3 #define SCE_HOLLYWOOD_KEYWORD 4 #define SCE_HOLLYWOOD_STDAPI 5 #define SCE_HOLLYWOOD_PLUGINAPI 6 #define SCE_HOLLYWOOD_PLUGINMETHOD 7 #define SCE_HOLLYWOOD_STRING 8 #define SCE_HOLLYWOOD_STRINGBLOCK 9 #define SCE_HOLLYWOOD_PREPROCESSOR 10 #define SCE_HOLLYWOOD_OPERATOR 11 #define SCE_HOLLYWOOD_IDENTIFIER 12 #define SCE_HOLLYWOOD_CONSTANT 13 #define SCE_HOLLYWOOD_HEXNUMBER 14 #define SCE_RAKU_DEFAULT 0 #define SCE_RAKU_ERROR 1 #define SCE_RAKU_COMMENTLINE 2 #define SCE_RAKU_COMMENTEMBED 3 #define SCE_RAKU_POD 4 #define SCE_RAKU_CHARACTER 5 #define SCE_RAKU_HEREDOC_Q 6 #define SCE_RAKU_HEREDOC_QQ 7 #define SCE_RAKU_STRING 8 #define SCE_RAKU_STRING_Q 9 #define SCE_RAKU_STRING_QQ 10 #define SCE_RAKU_STRING_Q_LANG 11 #define SCE_RAKU_STRING_VAR 12 #define SCE_RAKU_REGEX 13 #define SCE_RAKU_REGEX_VAR 14 #define SCE_RAKU_ADVERB 15 #define SCE_RAKU_NUMBER 16 #define SCE_RAKU_PREPROCESSOR 17 #define SCE_RAKU_OPERATOR 18 #define SCE_RAKU_WORD 19 #define SCE_RAKU_FUNCTION 20 #define SCE_RAKU_IDENTIFIER 21 #define SCE_RAKU_TYPEDEF 22 #define SCE_RAKU_MU 23 #define SCE_RAKU_POSITIONAL 24 #define SCE_RAKU_ASSOCIATIVE 25 #define SCE_RAKU_CALLABLE 26 #define SCE_RAKU_GRAMMAR 27 #define SCE_RAKU_CLASS 28 #define SCE_FSHARP_DEFAULT 0 #define SCE_FSHARP_KEYWORD 1 #define SCE_FSHARP_KEYWORD2 2 #define SCE_FSHARP_KEYWORD3 3 #define SCE_FSHARP_KEYWORD4 4 #define SCE_FSHARP_KEYWORD5 5 #define SCE_FSHARP_IDENTIFIER 6 #define SCE_FSHARP_QUOT_IDENTIFIER 7 #define SCE_FSHARP_COMMENT 8 #define SCE_FSHARP_COMMENTLINE 9 #define SCE_FSHARP_PREPROCESSOR 10 #define SCE_FSHARP_LINENUM 11 #define SCE_FSHARP_OPERATOR 12 #define SCE_FSHARP_NUMBER 13 #define SCE_FSHARP_CHARACTER 14 #define SCE_FSHARP_STRING 15 #define SCE_FSHARP_VERBATIM 16 #define SCE_FSHARP_QUOTATION 17 #define SCE_FSHARP_ATTRIBUTE 18 #define SCE_FSHARP_FORMAT_SPEC 19 #define SCE_ASCIIDOC_DEFAULT 0 #define SCE_ASCIIDOC_STRONG1 1 #define SCE_ASCIIDOC_STRONG2 2 #define SCE_ASCIIDOC_EM1 3 #define SCE_ASCIIDOC_EM2 4 #define SCE_ASCIIDOC_HEADER1 5 #define SCE_ASCIIDOC_HEADER2 6 #define SCE_ASCIIDOC_HEADER3 7 #define SCE_ASCIIDOC_HEADER4 8 #define SCE_ASCIIDOC_HEADER5 9 #define SCE_ASCIIDOC_HEADER6 10 #define SCE_ASCIIDOC_ULIST_ITEM 11 #define SCE_ASCIIDOC_OLIST_ITEM 12 #define SCE_ASCIIDOC_BLOCKQUOTE 13 #define SCE_ASCIIDOC_LINK 14 #define SCE_ASCIIDOC_CODEBK 15 #define SCE_ASCIIDOC_PASSBK 16 #define SCE_ASCIIDOC_COMMENT 17 #define SCE_ASCIIDOC_COMMENTBK 18 #define SCE_ASCIIDOC_LITERAL 19 #define SCE_ASCIIDOC_LITERALBK 20 #define SCE_ASCIIDOC_ATTRIB 21 #define SCE_ASCIIDOC_ATTRIBVAL 22 #define SCE_ASCIIDOC_MACRO 23 #define SCE_GD_DEFAULT 0 #define SCE_GD_COMMENTLINE 1 #define SCE_GD_NUMBER 2 #define SCE_GD_STRING 3 #define SCE_GD_CHARACTER 4 #define SCE_GD_WORD 5 #define SCE_GD_TRIPLE 6 #define SCE_GD_TRIPLEDOUBLE 7 #define SCE_GD_CLASSNAME 8 #define SCE_GD_FUNCNAME 9 #define SCE_GD_OPERATOR 10 #define SCE_GD_IDENTIFIER 11 #define SCE_GD_COMMENTBLOCK 12 #define SCE_GD_STRINGEOL 13 #define SCE_GD_WORD2 14 #define SCE_GD_ANNOTATION 15 #define SCE_GD_NODEPATH 16 #define SCE_TOML_DEFAULT 0 #define SCE_TOML_COMMENT 1 #define SCE_TOML_IDENTIFIER 2 #define SCE_TOML_KEYWORD 3 #define SCE_TOML_NUMBER 4 #define SCE_TOML_TABLE 5 #define SCE_TOML_KEY 6 #define SCE_TOML_ERROR 7 #define SCE_TOML_OPERATOR 8 #define SCE_TOML_STRING_SQ 9 #define SCE_TOML_STRING_DQ 10 #define SCE_TOML_TRIPLE_STRING_SQ 11 #define SCE_TOML_TRIPLE_STRING_DQ 12 #define SCE_TOML_ESCAPECHAR 13 #define SCE_TOML_DATETIME 14 #define SCE_TROFF_DEFAULT 0 #define SCE_TROFF_REQUEST 1 #define SCE_TROFF_COMMAND 2 #define SCE_TROFF_NUMBER 3 #define SCE_TROFF_OPERATOR 4 #define SCE_TROFF_STRING 5 #define SCE_TROFF_COMMENT 6 #define SCE_TROFF_IGNORE 7 #define SCE_TROFF_ESCAPE_STRING 8 #define SCE_TROFF_ESCAPE_MACRO 9 #define SCE_TROFF_ESCAPE_FONT 10 #define SCE_TROFF_ESCAPE_NUMBER 11 #define SCE_TROFF_ESCAPE_COLOUR 12 #define SCE_TROFF_ESCAPE_GLYPH 13 #define SCE_TROFF_ESCAPE_ENV 14 #define SCE_TROFF_ESCAPE_SUPPRESSION 15 #define SCE_TROFF_ESCAPE_SIZE 16 #define SCE_TROFF_ESCAPE_TRANSPARENT 17 #define SCE_TROFF_ESCAPE_ISVALID 18 #define SCE_TROFF_ESCAPE_DRAW 19 #define SCE_TROFF_ESCAPE_MOVE 20 #define SCE_TROFF_ESCAPE_HEIGHT 21 #define SCE_TROFF_ESCAPE_OVERSTRIKE 22 #define SCE_TROFF_ESCAPE_SLANT 23 #define SCE_TROFF_ESCAPE_WIDTH 24 #define SCE_TROFF_ESCAPE_VSPACING 25 #define SCE_TROFF_ESCAPE_DEVICE 26 #define SCE_TROFF_ESCAPE_NOMOVE 27 #define SCE_DART_DEFAULT 0 #define SCE_DART_COMMENTLINE 1 #define SCE_DART_COMMENTLINEDOC 2 #define SCE_DART_COMMENTBLOCK 3 #define SCE_DART_COMMENTBLOCKDOC 4 #define SCE_DART_STRING_SQ 5 #define SCE_DART_STRING_DQ 6 #define SCE_DART_TRIPLE_STRING_SQ 7 #define SCE_DART_TRIPLE_STRING_DQ 8 #define SCE_DART_RAWSTRING_SQ 9 #define SCE_DART_RAWSTRING_DQ 10 #define SCE_DART_TRIPLE_RAWSTRING_SQ 11 #define SCE_DART_TRIPLE_RAWSTRING_DQ 12 #define SCE_DART_ESCAPECHAR 13 #define SCE_DART_IDENTIFIER 14 #define SCE_DART_IDENTIFIER_STRING 15 #define SCE_DART_OPERATOR 16 #define SCE_DART_OPERATOR_STRING 17 #define SCE_DART_SYMBOL_IDENTIFIER 18 #define SCE_DART_SYMBOL_OPERATOR 19 #define SCE_DART_NUMBER 20 #define SCE_DART_KEY 21 #define SCE_DART_METADATA 22 #define SCE_DART_KW_PRIMARY 23 #define SCE_DART_KW_SECONDARY 24 #define SCE_DART_KW_TERTIARY 25 #define SCE_DART_KW_TYPE 26 #define SCE_ZIG_DEFAULT 0 #define SCE_ZIG_COMMENTLINE 1 #define SCE_ZIG_COMMENTLINEDOC 2 #define SCE_ZIG_COMMENTLINETOP 3 #define SCE_ZIG_NUMBER 4 #define SCE_ZIG_OPERATOR 5 #define SCE_ZIG_CHARACTER 6 #define SCE_ZIG_STRING 7 #define SCE_ZIG_MULTISTRING 8 #define SCE_ZIG_ESCAPECHAR 9 #define SCE_ZIG_IDENTIFIER 10 #define SCE_ZIG_FUNCTION 11 #define SCE_ZIG_BUILTIN_FUNCTION 12 #define SCE_ZIG_KW_PRIMARY 13 #define SCE_ZIG_KW_SECONDARY 14 #define SCE_ZIG_KW_TERTIARY 15 #define SCE_ZIG_KW_TYPE 16 #define SCE_ZIG_IDENTIFIER_STRING 17 #define SCE_NIX_DEFAULT 0 #define SCE_NIX_COMMENTLINE 1 #define SCE_NIX_COMMENTBLOCK 2 #define SCE_NIX_STRING 3 #define SCE_NIX_STRING_MULTILINE 4 #define SCE_NIX_ESCAPECHAR 5 #define SCE_NIX_IDENTIFIER 6 #define SCE_NIX_OPERATOR 7 #define SCE_NIX_OPERATOR_STRING 8 #define SCE_NIX_NUMBER 9 #define SCE_NIX_KEY 10 #define SCE_NIX_PATH 11 #define SCE_NIX_KEYWORD1 12 #define SCE_NIX_KEYWORD2 13 #define SCE_NIX_KEYWORD3 14 #define SCE_NIX_KEYWORD4 15 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */ #endif tmpok_q575y/lexilla/include/Lexilla.h0000664000175000017500000000654214773064066017400 0ustar gusnangusnan// Lexilla lexer library /** @file Lexilla.h ** Lexilla definitions for dynamic and static linking. ** For C++, more features and type safety are available with the LexillaAccess module. **/ // Copyright 2020 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef LEXILLA_H #define LEXILLA_H // Define the default Lexilla shared library name for each platform #if defined(_WIN32) #define LEXILLA_LIB "lexilla" #define LEXILLA_EXTENSION ".dll" #else #define LEXILLA_LIB "liblexilla" #if defined(__APPLE__) #define LEXILLA_EXTENSION ".dylib" #else #define LEXILLA_EXTENSION ".so" #endif #endif // On Win32 use the stdcall calling convention otherwise use the standard calling convention #if defined(_WIN32) #define LEXILLA_CALL __stdcall #else #define LEXILLA_CALL #endif #if defined(__OBJC2__) // Objective C(++) treats '[' as a message expression. #define DEPRECATE_DEFINITION #elif defined(__cplusplus) #define DEPRECATE_DEFINITION [[deprecated]] #elif defined(__GNUC__) || defined(__clang__) #define DEPRECATE_DEFINITION __attribute__((deprecated)) #else // MSVC __declspec(deprecated) has different positioning rules to GCC so define to nothing #define DEPRECATE_DEFINITION #endif #if defined(__cplusplus) // Must have already included ILexer.h to have Scintilla::ILexer5 defined. using Scintilla::ILexer5; #else typedef void ILexer5; #endif typedef ILexer5 *(*LexerFactoryFunction)(void); #if defined(__cplusplus) namespace Lexilla { #endif typedef int (LEXILLA_CALL *GetLexerCountFn)(void); typedef void (LEXILLA_CALL *GetLexerNameFn)(unsigned int Index, char *name, int buflength); typedef LexerFactoryFunction(LEXILLA_CALL *GetLexerFactoryFn)(unsigned int Index); typedef ILexer5*(LEXILLA_CALL *CreateLexerFn)(const char *name); DEPRECATE_DEFINITION typedef const char *(LEXILLA_CALL *LexerNameFromIDFn)(int identifier); typedef const char *(LEXILLA_CALL *GetLibraryPropertyNamesFn)(void); typedef void(LEXILLA_CALL *SetLibraryPropertyFn)(const char *key, const char *value); typedef const char *(LEXILLA_CALL *GetNameSpaceFn)(void); #if defined(__cplusplus) } #endif #define LEXILLA_NAMESPACE_SEPARATOR '.' #define LEXILLA_GETLEXERCOUNT "GetLexerCount" #define LEXILLA_GETLEXERNAME "GetLexerName" #define LEXILLA_GETLEXERFACTORY "GetLexerFactory" #define LEXILLA_CREATELEXER "CreateLexer" #define LEXILLA_LEXERNAMEFROMID "LexerNameFromID" #define LEXILLA_GETLIBRARYPROPERTYNAMES "GetLibraryPropertyNames" #define LEXILLA_SETLIBRARYPROPERTY "SetLibraryProperty" #define LEXILLA_GETNAMESPACE "GetNameSpace" // Static linking prototypes #if defined(__cplusplus) extern "C" { #endif ILexer5 * LEXILLA_CALL CreateLexer(const char *name); int LEXILLA_CALL GetLexerCount(void); void LEXILLA_CALL GetLexerName(unsigned int index, char *name, int buflength); LexerFactoryFunction LEXILLA_CALL GetLexerFactory(unsigned int index); DEPRECATE_DEFINITION const char *LEXILLA_CALL LexerNameFromID(int identifier); const char * LEXILLA_CALL GetLibraryPropertyNames(void); void LEXILLA_CALL SetLibraryProperty(const char *key, const char *value); const char *LEXILLA_CALL GetNameSpace(void); #if defined(__cplusplus) } #endif #if defined(__cplusplus) namespace Lexilla { class LexerModule; } // Add a static lexer (in the same binary) to Lexilla's list void AddStaticLexerModule(const Lexilla::LexerModule *plm); #endif #endif tmpok_q575y/lexilla/test/0000775000175000017500000000000014773064066015162 5ustar gusnangusnantmpok_q575y/lexilla/test/makefile0000664000175000017500000000312314773064066016661 0ustar gusnangusnan# Build all the lexer tests using GNU make and either g++ or Clang # @file makefile # Copyright 2019 by Neil Hodgson # The License.txt file describes the conditions under which this software may be distributed. # Should be run using mingw32-make on Windows, not nmake # On Windows g++ is used, on macOS clang, and on Linux g++ is used by default # but clang can be used by defining CLANG when invoking make # clang works only with libc++, not libstdc++ .PHONY: all test clean .SUFFIXES: .cxx WARNINGS = -Wpedantic -Wall -Wextra ifndef windir LIBS += -ldl ifeq ($(shell uname),Darwin) # On macOS always use Clang CLANG = 1 endif endif EXE = $(if $(windir),TestLexers.exe,TestLexers) BASE_FLAGS += --std=c++2a ifdef CLANG CXX = clang++ BASE_FLAGS += -fsanitize=address endif ifdef LEXILLA_STATIC DEFINES += -D LEXILLA_STATIC LIBS += ../bin/liblexilla.a endif ifdef windir DEL = $(if $(wildcard $(dir $(SHELL))rm.exe), $(dir $(SHELL))rm.exe -f, del /q) else DEL = rm -f endif vpath %.cxx ../access DEFINES += -D$(if $(DEBUG),DEBUG,NDEBUG) BASE_FLAGS += $(if $(DEBUG),-g,-O3) INCLUDES = -I ../../scintilla/include -I ../include -I ../access BASE_FLAGS += $(WARNINGS) all: $(EXE) test: $(EXE) ./$(EXE) clean: $(DEL) *.o *.obj $(EXE) %.o: %.cxx $(CXX) $(DEFINES) $(INCLUDES) $(BASE_FLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ OBJS = TestLexers.o TestDocument.o LexillaAccess.o $(EXE): $(OBJS) $(CXX) $(BASE_FLAGS) $(CPPFLAGS) $(CXXFLAGS) $^ $(LIBS) $(LDLIBS) -o $@ TestLexers.o: TestLexers.cxx TestDocument.h TestDocument.o: TestDocument.cxx TestDocument.h tmpok_q575y/lexilla/test/examples/0000775000175000017500000000000014773064066017000 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/hypertext/0000775000175000017500000000000014773064066021034 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/hypertext/Issue250RegEx.html.folded0000664000175000017500000000050314773064066025426 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue259CaseLower.html.folded0000664000175000017500000000125614773064066026317 0ustar gusnangusnan 0 400 0 0 400 0 0 400 0 <%@language=vbscript%> 2 400 0 + <% 0 401 0 | sub x 'comment 0 401 0 | peek 1024 0 401 0 | %> 2 400 0 + 2 401 0 + 0 402 0 | SinkWorld - Portability 0 402 0 | 0 402 0 | 0 402 0 | 0 402 0 | 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue252Tag.php0000664000175000017500000000051114773064066023517 0ustar gusnangusnan <%@language=JScript%> <% Response.Write('short') %> tmpok_q575y/lexilla/test/examples/hypertext/ServerJavaScript.aspx.folded0000664000175000017500000000112014773064066026414 0ustar gusnangusnan 0 400 0 2 400 0 + 0 401 0 | <%@language=JScript%> 0 401 0 | <%-- comment --%> 2 401 0 + 2 401 0 + 0 401 0 | Start 0 401 0 | <%Response.Write("1")%> 0 401 0 | <%var x=3;//comment%> 0 401 0 | <%x=3;//comment ?> %> 0 401 0 | <%Response.Write(x)%> 0 401 0 | <%Response.Write(`template ${2+2}`)%> 0 401 0 | End 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/ServerBasic.aspx.folded0000664000175000017500000000131414773064066025374 0ustar gusnangusnan 2 400 0 + <%@ register tagprefix="uc1" 0 401 0 | tagname="CalendarUserControl" 0 401 0 | src="~/CalendarUserControl.ascx" %> 0 400 0 2 400 0 + 0 401 0 | <%@language=VBScript%> 0 401 0 | <%-- comment --%> 2 401 0 + 2 401 0 + 0 401 0 | Start 0 401 0 | <%response.write("1")%> 0 401 0 | <% 'comment%> 0 401 0 | <%dim x="2"'comment%> 0 401 0 | <%response.write(x)%> 0 401 0 | End 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/x.asp.folded0000664000175000017500000000104214773064066023241 0ustar gusnangusnan 0 400 0 <%@language=javas%> 2 400 0 + <% 0 401 0 | #include 0 401 0 | serve x; 2 401 0 + function x() { 0 402 0 | } 0 401 0 | %> 0 400 0 <%@language=vbscript%> 2 400 0 + <% 0 401 0 | sub x 'comment 0 401 0 | peek 1024 0 401 0 | %> 0 400 0 0 400 0 <%@language=python%> 0 400 0 <% 0 400 0 import random 0 400 0 x = 'comment' 0 400 0 parse "x=8" 0 400 0 %> 2 3ff 0 + 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Bug2207.html.folded0000664000175000017500000000041314773064066024204 0ustar gusnangusnan 0 400 0 2 400 0 + 2 401 0 + 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue273JavaScript.html0000664000175000017500000000032514773064066025235 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/Issue259CaseLower.html0000664000175000017500000000073614773064066025065 0ustar gusnangusnan <%@language=vbscript%> <% sub x 'comment peek 1024 %> SinkWorld - Portability tmpok_q575y/lexilla/test/examples/hypertext/Issue272SGML.xml.folded0000664000175000017500000000060014773064066025014 0ustar gusnangusnan 2 400 0 + 0 401 0 | 0 401 0 | 2 401 0 + An ampersand (&#38;) may be escaped 0 402 0 | numerically (&#38;#38) or with a general entity (&amp;).

" > 0 401 0 | ]> 0 400 0 &example; 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue19.php.folded0000664000175000017500000000145714773064066024252 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/ServerJavaScript.aspx.styled0000664000175000017500000000120714773064066026471 0ustar gusnangusnan{21}{0} {1}{0} {15}<%@{16}language=JScript{15}%>{0} {15}<%--{20} comment --{15}%>{0} {1}{40} {43}//%>{41} {43}//?>{41} {1}{0} {1}{40} {46}e{50}={48}"%>"{50};{41} {46}f{50}={48}"?>"{50};{41} {1}{0} Start {15}<%{61}Response.Write{65}({63}"1"{65}){15}%>{0} {15}<%{62}var{56} {61}x{65}={60}3{65};{58}//comment{15}%>{0} {15}<%{61}x{65}={60}3{65};{58}//comment ?> {15}%>{0} {15}<%{61}Response.Write{65}({61}x{65}){15}%>{0} {15}<%{61}Response.Write{65}({68}`template ${2+2}`{65}){15}%>{0} End {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/x.asp.styled0000664000175000017500000000104114773064066023307 0ustar gusnangusnan{15}<%@{16}language=javas{15}%>{0} {15}<%{56} #{61}include{56} {195}serve{56} {61}x{65};{56} {62}function{56} {61}x{65}(){56} {65}{{56} {65}}{56} {15}%>{0} {15}<%@{16}language=vbscript{15}%>{0} {15}<%{81} {84}sub{81} {86}x{81} {82}'comment {81} {196}peek{81} {83}1024{81} {15}%>{0} {9}{0} {15}<%@{16}language=python{15}%>{0} {15}<%{106} {111}import{106} {117}random{106} {117}x{106} {116}={106} {110}'comment'{106} {197}parse{106} {109}"x=8"{106} {15}%>{0} {1}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue19.php.styled0000664000175000017500000000143614773064066024316 0ustar gusnangusnan{18}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue53.html.folded0000664000175000017500000000017714773064066024423 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/comment.html.styled0000664000175000017500000000070614773064066024672 0ustar gusnangusnan{9}{1}

{0}1 normal comment{1}

{0} {9}{1}

{0}2 valid comment{1}

{0} {9}{1}

{0}3 abrupt-closing-of-empty-comment{1}

{0} {9}{1}

{0}4 abrupt-closing-of-empty-comment{1}

{0} {9}{1}

{0}5 incorrectly-closed-comment{1}

{0} {9}{1}

{0}6 incorrectly-closed-comment{1}

{0} {9}{1}

{0}7 nested-comment{1}

{0} {9}{1}

{0}8 nested-comment{1}

{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue252Tag.php.folded0000664000175000017500000000116414773064066024760 0ustar gusnangusnan 0 400 0 1 400 0 0 400 0 2 400 0 + 1 400 0 0 400 0 0 400 0 1 400 0 0 400 0 0 400 0 1 401 0 | 0 401 0 | 2 401 0 + <%@language=JScript%> 1 402 0 | 0 402 0 | 0 402 0 | <% 0 402 0 | Response.Write('short') 2 402 0 + %> 0 403 0 | tmpok_q575y/lexilla/test/examples/hypertext/Issue288.php0000664000175000017500000000005414773064066023076 0ustar gusnangusnan ") tmpok_q575y/lexilla/test/examples/hypertext/comment.html0000664000175000017500000000051614773064066023366 0ustar gusnangusnan

1 normal comment

2 valid comment

3 abrupt-closing-of-empty-comment

4 abrupt-closing-of-empty-comment

5 incorrectly-closed-comment

6 incorrectly-closed-comment

7 nested-comment

8 nested-comment

tmpok_q575y/lexilla/test/examples/hypertext/SciTE.properties0000664000175000017500000000210114773064066024113 0ustar gusnangusnanlexer.*=hypertext # Tags and attributes keywords.*=b br body content div encoding head href html IMG language li link meta \ name p rel runat script Src strong title type ul version xml xmlns # JavaScript keywords2.*=function var # Basic keywords3.*=dim sub # Python keywords4.*=import pass # PHP keywords5.*=echo __file__ __line__ # SGML keywords6.*=DOCTYPE ELEMENT ENTITY NOTATION # Tag substyles.hypertext.1=1 substylewords.1.1.*=Destination # Attribute substyles.hypertext.3=1 substylewords.3.1.*=from img.height img.Width # JavaScript substyles.hypertext.46=1 substylewords.46.1.*=let # Server JavaScript substyles.hypertext.61=1 substylewords.61.1.*=serve # Basic substyles.hypertext.74=1 substylewords.74.1.*=PEEK # Python substyles.hypertext.96=1 substylewords.96.1.*=parse # PHP substyles.hypertext.121=1 substylewords.121.1.*=decrypt nl2br fold=1 fold.html=1 fold.html.preprocessor=1 fold.hypertext.comment=1 match Issue273JavaScript.html fold.hypertext.comment=0 match mako.html lexer.html.mako=1 match Issue252Tag.php lexer.html.allow.php=1 lexer.html.allow.asp=0 tmpok_q575y/lexilla/test/examples/hypertext/Issue252Tag.php.styled0000664000175000017500000000071414773064066025027 0ustar gusnangusnan{9}{0} {9}{0} {18}{0} {9}{0} {18}{0} {9}{0} {2}{0} {9}{0} {2}<%@language=JScript%>{0} {9}{0} {2}<% Response.Write('short') %>{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue272SGML.xml.styled0000664000175000017500000000063714773064066025075 0ustar gusnangusnan{21}{31} {21}{31} {21}{31} {21}An ampersand (&#38;) may be escaped numerically (&#38;#38) or with a general entity (&amp;).

"{21} >{31} {21}]>{0} {2}{10}&example;{2}{0} tmpok_q575y/lexilla/test/examples/hypertext/ServerBasic.aspx.styled0000664000175000017500000000131314773064066025442 0ustar gusnangusnan{15}<%@{16} register tagprefix="uc1" tagname="CalendarUserControl" src="~/CalendarUserControl.ascx" {15}%>{0} {21}{0} {1}{0} {15}<%@{16}language=VBScript{15}%>{0} {15}<%--{20} comment --{15}%>{0} {1}{70} {72}'1%>2{71} {72}'1?>2{71} {72}'%>{71} {72}'?>{71} {1}{0} {1}{70} {74}dim{71} {76}e{71}={75}"%>"{71} {74}dim{71} {76}f{71}={75}"?>"{71} {1}{0} Start {15}<%{86}response.write{81}({85}"1"{81}){15}%>{0} {15}<%{81} {82}'comment{15}%>{0} {15}<%{84}dim{81} {86}x{81}={85}"2"{82}'comment{15}%>{0} {15}<%{86}response.write{81}({86}x{81}){15}%>{0} End {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/ServerBasic.aspx0000664000175000017500000000060714773064066024144 0ustar gusnangusnan<%@ register tagprefix="uc1" tagname="CalendarUserControl" src="~/CalendarUserControl.ascx" %> <%@language=VBScript%> <%-- comment --%> Start <%response.write("1")%> <% 'comment%> <%dim x="2"'comment%> <%response.write(x)%> End tmpok_q575y/lexilla/test/examples/hypertext/Issue192.html.styled0000664000175000017500000000056114773064066024553 0ustar gusnangusnan{2}&{0} {2}&1{0} {2}&A{0} {2}&{0}中 {2}&{1}{0} {2}&1{1}{0} {2}&A{1}{0} {2}&{0}中{1}{0} {2}&{10}&{0} {10}{0} {10}{0}中 {10}&A;{1}{0} {10}{1}{0} {10}{0}中{1}{0} {2}&{0} {10}<{0} {10}<{1}{0} {10}&b.eps;{0} {2}&b.eps{0}! {2}&{0}—; tmpok_q575y/lexilla/test/examples/hypertext/Issue272SGML.xml0000664000175000017500000000041314773064066023562 0ustar gusnangusnan An ampersand (&#38;) may be escaped numerically (&#38;#38) or with a general entity (&amp;).

" > ]> &example; tmpok_q575y/lexilla/test/examples/hypertext/Issue250RegEx.html0000664000175000017500000000026414773064066024176 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/Issue273JavaScript.html.folded0000664000175000017500000000067714773064066026503 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue47.html.folded0000664000175000017500000000024514773064066024422 0ustar gusnangusnan 2 400 0 + 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue250RegEx.html.styled0000664000175000017500000000064114773064066025500 0ustar gusnangusnan{1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue20Numbers.php0000664000175000017500000000105114773064066024330 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/x.php.folded0000664000175000017500000000163714773064066023257 0ustar gusnangusnan 2 400 0 + 2 401 0 + \n"; 0 402 0 | /* ?> */ 0 402 0 | ?> 0 401 0 | forif 0 401 0 | 0 401 0 | 2 401 0 + 0 401 0 | tmpok_q575y/lexilla/test/examples/hypertext/mako.html.folded0000664000175000017500000000663714773064066024121 0ustar gusnangusnan 0 400 0 Mako examples extracted from https://docs.makotemplates.org/en/latest/syntax.html 1 400 0 0 400 0 Expression 0 400 0 ${x} 0 400 0 ${} 0 400 0 ${pow(x,2) + pow(y,2)} 1 400 0 0 400 0 Expression Escaping 0 400 0 ${"this is some text" | u} 1 400 0 0 400 0 Control Structures 0 400 0 % if x==5: 0 400 0 this is some output 0 400 0 % endif 1 400 0 0 400 0 % for a in ['one', 'two', 'three', 'four', 'five']: 0 400 0 % if a[0] == 't': 0 400 0 its two or three 0 400 0 % elif a[0] == 'f': 0 400 0 four/five 0 400 0 % else: 0 400 0 one 0 400 0 % endif 0 400 0 % endfor 1 400 0 0 400 0 The % sign can also be “escaped”, if you actually want to emit a percent sign as the first non whitespace character on a line, by escaping it as in %%: 0 400 0 %% some text 0 400 0 %% some more text 1 400 0 0 400 0 The Loop Context 0 400 0 The loop context provides additional information about a loop while inside of a % for structure: 1 400 0 2 400 0 +
    0 401 0 | % for a in ("one", "two", "three"): 0 401 0 |
  • Item ${loop.index}: ${a}
    • 0 401 0 | % endfor 0 401 0 |
1 400 0 0 400 0 A multiline version exists using <%doc> ...text... : 0 400 0 <%doc> 0 400 0 these are comments 0 400 0 more comments 0 400 0 1 400 0 0 400 0 Python Blocks 0 400 0 Any arbitrary block of python can be dropped in using the <% %> tags: 0 400 0 this is a template 1 400 0 0 400 0 <% 0 400 0 x = db.get_resource('foo') 0 400 0 y = [z.element for z in x if x.frobnizzle==5] 0 400 0 %> 0 400 0 % for elem in y: 0 400 0 element: ${elem} 0 400 0 % endfor 0 400 0 Within <% %>, you’re writing a regular block of Python code. While the code can appear with an arbitrary level of preceding whitespace, it has to be consistently formatted with itself. Mako’s compiler will adjust the block of Python to be consistent with the surrounding generated Python code. 1 400 0 0 400 0 Module-level Blocks 0 400 0 A variant on <% %> is the module-level code block, denoted by <%! %>. Code within these tags is executed at the module level of the template, and not within the rendering function of the template. Therefore, this code does not have access to the template’s context and is only executed when the template is loaded into memory (which can be only once per application, or more, depending on the runtime environment). Use the <%! %> tags to declare your template’s imports, as well as any pure-Python functions you might want to declare: 1 400 0 0 400 0 <%! 0 400 0 import mylib 0 400 0 import re 1 400 0 0 400 0 def filter(text): 0 400 0 return re.sub(r'^@', '', text) 0 400 0 %> 1 400 0 0 400 0 Tags 0 400 0 The rest of what Mako offers takes place in the form of tags. All tags use the same syntax, which is similar to an XML tag except that the first character of the tag name is a % character. The tag is closed either by a contained slash character, or an explicit closing tag: 1 400 0 0 400 0 <%include file="foo.txt"/> 1 400 0 0 400 0 <%def name="foo" buffered="True"> 0 400 0 this is a def 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/apostophe.php.styled0000664000175000017500000000055114773064066025053 0ustar gusnangusnan{18}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/x.html.folded0000664000175000017500000000155414773064066023432 0ustar gusnangusnan 0 400 0 2 400 0 + 2 401 0 + 2 401 0 + 0 402 0 | 0 402 0 | SinkWorld - Portability 0 402 0 | § 0 402 0 | SinkWorld - Portability 0 402 0 | 0 402 0 | 0 402 0 | 0 402 0 | 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/comment.html.folded0000664000175000017500000000070314773064066024620 0ustar gusnangusnan 0 400 0

1 normal comment

0 400 0

2 valid comment

0 400 0

3 abrupt-closing-of-empty-comment

0 400 0

4 abrupt-closing-of-empty-comment

0 400 0

5 incorrectly-closed-comment

0 400 0

6 incorrectly-closed-comment

0 400 0

7 nested-comment

0 400 0

8 nested-comment

0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue192.html.folded0000664000175000017500000000065014773064066024503 0ustar gusnangusnan 0 400 0 & 0 400 0 &1 0 400 0 &A 0 400 0 &中 0 400 0 &
0 400 0 &1
0 400 0 &A
0 400 0 &中
0 400 0 && 0 400 0  0 400 0 中 0 400 0 &A;
0 400 0 
0 400 0 中
0 400 0 & 0 400 0 < 0 400 0 <
0 400 0 &b.eps; 0 400 0 &b.eps! 0 400 0 &—; 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue19.php0000664000175000017500000000063414773064066023012 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/Issue288.php.styled0000664000175000017500000000011614773064066024400 0ustar gusnangusnan{18} "{127}){118} tmpok_q575y/lexilla/test/examples/hypertext/Issue47.html0000664000175000017500000000007514773064066023167 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/x.html.styled0000664000175000017500000000177514773064066023506 0ustar gusnangusnan{12}{0} {1}{0} {1}{40} {47}var{41} {46}b{41} {50}={41} {52}/abc/i{50}.{46}test{50}({49}'abc'{50});{41} {194}let{41} {46}b{41} {50}={41} {45}1{50};{41} {49}'x\ '{41} {43}// issue 214 fix to behave same as single quote escaped eol{41} {48}"x\ "{41} {1}{0} {1}{0} {1}{0} {1}{0}SinkWorld - Portability{1}{0} § {2}{0}SinkWorld - Portability{2}{0} {1}{0} {1}{0} {192}{192}{0} {1}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Bug2219.html0000664000175000017500000000003414773064066022752 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/x.html0000664000175000017500000000111614773064066022170 0ustar gusnangusnan SinkWorld - Portability § SinkWorld - Portability tmpok_q575y/lexilla/test/examples/hypertext/Issue20Numbers.php.styled0000664000175000017500000000246614773064066025646 0ustar gusnangusnan{18}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue53.html0000664000175000017500000000006114773064066023157 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/x.asp0000664000175000017500000000040414773064066022006 0ustar gusnangusnan<%@language=javas%> <% #include serve x; function x() { } %> <%@language=vbscript%> <% sub x 'comment peek 1024 %> <%@language=python%> <% import random x = 'comment' parse "x=8" %> tmpok_q575y/lexilla/test/examples/hypertext/Issue273JavaScript.html.styled0000664000175000017500000000055614773064066026546 0ustar gusnangusnan{1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue20Numbers.php.folded0000664000175000017500000000167414773064066025577 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Issue53.html.styled0000664000175000017500000000015214773064066024463 0ustar gusnangusnan{1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue47.html.styled0000664000175000017500000000017614773064066024474 0ustar gusnangusnan{1}{40} {43}// comment{41} {1}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Bug2219.html.folded0000664000175000017500000000016714773064066024215 0ustar gusnangusnan 2 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Bug2219.html.styled0000664000175000017500000000006114773064066024255 0ustar gusnangusnan{1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Bug2207.html0000664000175000017500000000024314773064066022751 0ustar gusnangusnan tmpok_q575y/lexilla/test/examples/hypertext/x.php.styled0000664000175000017500000000215014773064066023315 0ustar gusnangusnan{1}{0} {9}{0} {18}\n"{127};{118} {124}/* ?> */{118} {18}?>{0} {1}{0}for{1}{0}if{1}{0} {18}{0} {18}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/Issue259CaseLower.html.styled0000664000175000017500000000143414773064066026364 0ustar gusnangusnan{12}{0} {9}{0} {15}<%@{16}language=vbscript{15}%>{0} {15}<%{81} {84}sub{81} {86}x{81} {82}'comment {81} {196}peek{81} {83}1024{81} {15}%>{0} {1}{0} {1}{0} {2}{0}SinkWorld - Portability{2}{0} {1}{0} {1}{0} {192}{192}{0} {1}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/apostophe.php0000664000175000017500000000026614773064066023553 0ustar gusnangusnan
tmpok_q575y/lexilla/test/examples/hypertext/apostophe.php.folded0000664000175000017500000000052214773064066025002 0ustar gusnangusnan 2 400 0 + 1 400 0 0 400 0
0 400 0 tmpok_q575y/lexilla/test/examples/hypertext/Bug2207.html.styled0000664000175000017500000000045714773064066024263 0ustar gusnangusnan{21}{0} {1}{0} {1}{0} {1}{0} tmpok_q575y/lexilla/test/examples/hypertext/ServerJavaScript.aspx0000664000175000017500000000047714773064066025176 0ustar gusnangusnan <%@language=JScript%> <%-- comment --%> Start <%Response.Write("1")%> <%var x=3;//comment%> <%x=3;//comment ?> %> <%Response.Write(x)%> <%Response.Write(`template ${2+2}`)%> End tmpok_q575y/lexilla/test/examples/hypertext/Issue192.html0000664000175000017500000000023214773064066023243 0ustar gusnangusnan& &1 &A &中 &
&1
&A
&中
&&  中 &A;

中
& < <
&b.eps; &b.eps! &—; tmpok_q575y/lexilla/test/examples/hypertext/mako.html.styled0000664000175000017500000000750714773064066024165 0ustar gusnangusnan{0}Mako examples extracted from https://docs.makotemplates.org/en/latest/syntax.html Expression {15}${{117}x{15}}{0} {15}${}{0} {15}${{117}pow{116}({117}x{116},{108}2{116}){106} {116}+{106} {117}pow{116}({117}y{116},{108}2{116}){15}}{0} Expression Escaping {15}${{109}"this is some text"{106} {116}|{106} {117}u{15}}{0} Control Structures {15}%{106} {117}if{106} {117}x{116}=={108}5{116}:{0} this is some output {15}%{106} {117}endif{0} {15}%{106} {117}for{106} {117}a{106} {117}in{106} {116}[{110}'one'{116},{106} {110}'two'{116},{106} {110}'three'{116},{106} {110}'four'{116},{106} {110}'five'{116}]:{0} {15}%{106} {117}if{106} {117}a{116}[{108}0{116}]{106} {116}=={106} {110}'t'{116}:{0} its two or three {15}%{106} {117}elif{106} {117}a{116}[{108}0{116}]{106} {116}=={106} {110}'f'{116}:{0} four/five {15}%{106} {117}else{116}:{0} one {15}%{106} {117}endif{0} {15}%{106} {117}endfor{0} The % sign can also be “escaped”, if you actually want to emit a percent sign as the first non whitespace character on a line, by escaping it as in %%: {15}%{116}%{106} {117}some{106} {117}text{0} {15}%{116}%{106} {117}some{106} {117}more{106} {117}text{0} The Loop Context The loop context provides additional information about a loop while inside of a % for structure: {1}
    {0} {15}%{106} {117}for{106} {117}a{106} {117}in{106} {116}({109}"one"{116},{106} {109}"two"{116},{106} {109}"three"{116}):{0} {1}
  • {0}Item {15}${{117}loop.index{15}}{0}: {15}${{117}a{15}}{1}
    • {0} {15}%{106} {117}endfor{0} {1}
{0} A multiline version exists using {15}<%{2}doc{15}>{0} ...text... {15}{0}: {15}<%{2}doc{15}>{0} these are comments more comments {15}{0} Python Blocks Any arbitrary block of python can be dropped in using the {15}<%{106} {15}%>{0} tags: this is a template {15}<%{105} {106} {117}x{106} {116}={106} {117}db.get_resource{116}({110}'foo'{116}){106} {117}y{106} {116}={106} {116}[{117}z.element{106} {117}for{106} {117}z{106} {117}in{106} {117}x{106} {117}if{106} {117}x.frobnizzle{116}=={108}5{116}]{106} {15}%>{0} {15}%{106} {117}for{106} {117}elem{106} {117}in{106} {117}y{116}:{0} element: {15}${{117}elem{15}}{0} {15}%{106} {117}endfor{0} Within {15}<%{106} {15}%>{0}, you’re writing a regular block of Python code. While the code can appear with an arbitrary level of preceding whitespace, it has to be consistently formatted with itself. Mako’s compiler will adjust the block of Python to be consistent with the surrounding generated Python code. Module-level Blocks A variant on {15}<%{106} {15}%>{0} is the module-level code block, denoted by {15}<%{116}!{106} {15}%>{0}. Code within these tags is executed at the module level of the template, and not within the rendering function of the template. Therefore, this code does not have access to the template’s context and is only executed when the template is loaded into memory (which can be only once per application, or more, depending on the runtime environment). Use the {15}<%{116}!{106} {15}%>{0} tags to declare your template’s imports, as well as any pure-Python functions you might want to declare: {15}<%{116}!{105} {106} {111}import{106} {117}mylib{106} {111}import{106} {117}re{106} {117}def{106} {115}filter{116}({117}text{116}):{106} {117}return{106} {117}re.sub{116}({117}r{110}'^@'{116},{106} {110}''{116},{106} {117}text{116}){106} {15}%>{0} Tags The rest of what Mako offers takes place in the form of tags. All tags use the same syntax, which is similar to an XML tag except that the first character of the tag name is a % character. The tag is closed either by a contained slash character, or an explicit closing tag: {15}<%{2}include{106} {117}file{116}={109}"foo.txt"{15}/>{0} {15}<%{2}def{106} {117}name{116}={109}"foo"{106} {117}buffered{116}={109}"True"{15}>{0} this is a def {15}{0} tmpok_q575y/lexilla/test/examples/hypertext/x.php0000664000175000017500000000121614773064066022014 0ustar gusnangusnan \n"; /* ?> */ ?> forif tmpok_q575y/lexilla/test/examples/hypertext/Issue288.php.folded0000664000175000017500000000015514773064066024334 0ustar gusnangusnan 2 400 0 + 0 401 0 | ") 0 401 0 | tmpok_q575y/lexilla/test/examples/hypertext/mako.html0000664000175000017500000000466614773064066022665 0ustar gusnangusnanMako examples extracted from https://docs.makotemplates.org/en/latest/syntax.html Expression ${x} ${} ${pow(x,2) + pow(y,2)} Expression Escaping ${"this is some text" | u} Control Structures % if x==5: this is some output % endif % for a in ['one', 'two', 'three', 'four', 'five']: % if a[0] == 't': its two or three % elif a[0] == 'f': four/five % else: one % endif % endfor The % sign can also be “escaped”, if you actually want to emit a percent sign as the first non whitespace character on a line, by escaping it as in %%: %% some text %% some more text The Loop Context The loop context provides additional information about a loop while inside of a % for structure:
    % for a in ("one", "two", "three"):
  • Item ${loop.index}: ${a}
    • % endfor
A multiline version exists using <%doc> ...text... : <%doc> these are comments more comments Python Blocks Any arbitrary block of python can be dropped in using the <% %> tags: this is a template <% x = db.get_resource('foo') y = [z.element for z in x if x.frobnizzle==5] %> % for elem in y: element: ${elem} % endfor Within <% %>, you’re writing a regular block of Python code. While the code can appear with an arbitrary level of preceding whitespace, it has to be consistently formatted with itself. Mako’s compiler will adjust the block of Python to be consistent with the surrounding generated Python code. Module-level Blocks A variant on <% %> is the module-level code block, denoted by <%! %>. Code within these tags is executed at the module level of the template, and not within the rendering function of the template. Therefore, this code does not have access to the template’s context and is only executed when the template is loaded into memory (which can be only once per application, or more, depending on the runtime environment). Use the <%! %> tags to declare your template’s imports, as well as any pure-Python functions you might want to declare: <%! import mylib import re def filter(text): return re.sub(r'^@', '', text) %> Tags The rest of what Mako offers takes place in the form of tags. All tags use the same syntax, which is similar to an XML tag except that the first character of the tag name is a % character. The tag is closed either by a contained slash character, or an explicit closing tag: <%include file="foo.txt"/> <%def name="foo" buffered="True"> this is a def tmpok_q575y/lexilla/test/examples/visualprolog/0000775000175000017500000000000014773064066021526 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pro.folded0000664000175000017500000000410314773064066025416 0ustar gusnangusnan 0 400 400 % SCE_VISUALPROLOG_KEY_MAJOR (1) 0 400 400 goal 0 400 400 0 400 400 % SCE_VISUALPROLOG_KEY_MINOR (2) 0 400 400 procedure 0 400 400 0 400 400 % SCE_VISUALPROLOG_KEY_DIRECTIVE (3) 0 400 400 #include 0 400 400 0 400 400 % SCE_VISUALPROLOG_COMMENT_BLOCK (4) 0 400 400 /** 0 400 400 SCE_VISUALPROLOG_COMMENT_KEY (6) 0 400 400 @detail 0 400 400 SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) 0 400 400 @unknown 0 400 400 /* SCE_VISUALPROLOG_IDENTIFIER (8) 0 400 400 SCE_VISUALPROLOG_VARIABLE (9) 0 400 400 SCE_VISUALPROLOG_ANONYMOUS (10) 0 400 400 SCE_VISUALPROLOG_NUMBER (11) 0 400 400 SCE_VISUALPROLOG_OPERATOR (12) */ */ 2 400 401 + lambda = { 0 401 401 | (A) = { (B, _discard) = A*B+1 } 0 401 400 | }. 0 400 400 0 400 400 % SCE_VISUALPROLOG_COMMENT_LINE (5) 0 400 400 % comment line 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_QUOTE (16) 0 400 400 "" 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING (20) 0 400 400 "string" 0 400 400 'string' 0 400 400 @"verbatim string" 0 400 400 @[
] 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_ESCAPE (17) 0 400 400 "\n" 0 400 400 '\uAB12' 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18) 0 400 400 "\ " 0 400 400 "open string 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_EOL (22) 0 400 400 @#multi-line 0 400 400 verbatim 0 400 400 string# 0 400 400 0 400 400 % SCE_VISUALPROLOG_EMBEDDED (23) 0 400 400 [| |] 0 400 400 % SCE_VISUALPROLOG_PLACEHOLDER (24) 0 400 400 {| |}:test 0 400 400 % line state & nesting 0 400 400 [| 0 400 400 {| 0 400 400 /* 0 400 400 % /* 0 400 400 */ 0 400 400 % */ 0 400 400 [| 0 400 400 {| 0 400 400 @!string! 0 400 400 % 0 400 400 /* 0 400 400 */ 0 400 400 |} 0 400 400 |] 0 400 400 |} 0 400 400 |] 1 400 400 tmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pl0000664000175000017500000000232014773064066023774 0ustar gusnangusnan% SCE_VISUALPROLOG_KEY_MAJOR (1) % No keywords in ISO/SWI-Prolog goal % SCE_VISUALPROLOG_KEY_MINOR (2) % No minor keywords in ISO/SWI-Prolog procedure % SCE_VISUALPROLOG_KEY_DIRECTIVE (3) % No directives in ISO/SWI-Prolog #include % SCE_VISUALPROLOG_COMMENT_BLOCK (4) /** SCE_VISUALPROLOG_COMMENT_KEY (6) @detail SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) @unknown /* SCE_VISUALPROLOG_IDENTIFIER (8) SCE_VISUALPROLOG_VARIABLE (9) SCE_VISUALPROLOG_ANONYMOUS (10) SCE_VISUALPROLOG_NUMBER (11) SCE_VISUALPROLOG_OPERATOR (12) */ */ singleton --> [S], { string_lower(S, L), atom_codes(L, Bytes), sort(0, @=<, Bytes, [95, _discard]) }. % SCE_VISUALPROLOG_COMMENT_LINE (5) % comment line % SCE_VISUALPROLOG_STRING_QUOTE (16) "" % SCE_VISUALPROLOG_STRING (20) "string" 'string' % ISO Prolog back-quoted string `string` % SCE_VISUALPROLOG_STRING_ESCAPE (17) "\n" '\uAB12' % SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18) "\ " "open string % Not implemented for ISO/SWI-Prolog: @"verbatim string" @[
] % SCE_VISUALPROLOG_STRING_EOL (22) @#multi-line verbatim string# % SCE_VISUALPROLOG_EMBEDDED (23) [| |] % SCE_VISUALPROLOG_PLACEHOLDER (24) {| |}:test tmpok_q575y/lexilla/test/examples/visualprolog/SciTE.properties0000664000175000017500000000221514773064066024613 0ustar gusnangusnanlexer.*.pro;*.pl=visualprolog fold=1 # Visual Prolog properties match AllStyles.pro lexer.visualprolog.verbatim.strings=1 lexer.visualprolog.backquoted.strings=0 # ISO/SWI-Prolog properties match AllStyles.pl lexer.visualprolog.verbatim.strings=0 lexer.visualprolog.backquoted.strings=1 # major keywords keywords.*.pro;*.pl=goal namespace interface class implement open inherits supports resolve delegate \ monitor constants domains predicates constructors properties clauses facts string_lower atom_codes sort # minor keywords keywords2.*.pro;*.pl=any binary binaryNonAtomic boolean char compareResult factDB guard handle integer64 \ integerNative language null pointer real real32 stdcall string8 symbol apicall c thiscall prolog \ digits if then elseif else endif foreach do try catch finally erroneous failure procedure determ multi \ nondeterm anyflow and or externally from div mod rem quot in orelse otherwise unsigned unsigned64 \ unsignedNative # directives keywords3.*.pro;*.pl=include bininclude requires orrequires error message export externally options # documentation keywords keywords4.*.pro;*.pl=short detail end exception withdomain tmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pl.folded0000664000175000017500000000405214773064066025234 0ustar gusnangusnan 0 400 400 % SCE_VISUALPROLOG_KEY_MAJOR (1) 0 400 400 % No keywords in ISO/SWI-Prolog 0 400 400 goal 0 400 400 0 400 400 % SCE_VISUALPROLOG_KEY_MINOR (2) 0 400 400 % No minor keywords in ISO/SWI-Prolog 0 400 400 procedure 0 400 400 0 400 400 % SCE_VISUALPROLOG_KEY_DIRECTIVE (3) 0 400 400 % No directives in ISO/SWI-Prolog 0 400 400 #include 0 400 400 0 400 400 % SCE_VISUALPROLOG_COMMENT_BLOCK (4) 0 400 400 /** 0 400 400 SCE_VISUALPROLOG_COMMENT_KEY (6) 0 400 400 @detail 0 400 400 SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) 0 400 400 @unknown 0 400 400 /* SCE_VISUALPROLOG_IDENTIFIER (8) 0 400 400 SCE_VISUALPROLOG_VARIABLE (9) 0 400 400 SCE_VISUALPROLOG_ANONYMOUS (10) 0 400 400 SCE_VISUALPROLOG_NUMBER (11) 0 400 400 SCE_VISUALPROLOG_OPERATOR (12) */ */ 0 400 400 singleton --> 0 400 400 [S], 2 400 401 + { 0 401 401 | string_lower(S, L), 0 401 401 | atom_codes(L, Bytes), 0 401 401 | sort(0, @=<, Bytes, [95, _discard]) 0 401 400 | }. 0 400 400 0 400 400 % SCE_VISUALPROLOG_COMMENT_LINE (5) 0 400 400 % comment line 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_QUOTE (16) 0 400 400 "" 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING (20) 0 400 400 "string" 0 400 400 'string' 0 400 400 0 400 400 % ISO Prolog back-quoted string 0 400 400 `string` 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_ESCAPE (17) 0 400 400 "\n" 0 400 400 '\uAB12' 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18) 0 400 400 "\ " 0 400 400 "open string 0 400 400 0 400 400 % Not implemented for ISO/SWI-Prolog: 0 400 400 @"verbatim string" 0 400 400 @[
] 0 400 400 0 400 400 % SCE_VISUALPROLOG_STRING_EOL (22) 0 400 400 @#multi-line 0 400 400 verbatim 0 400 400 string# 0 400 400 0 400 400 % SCE_VISUALPROLOG_EMBEDDED (23) 0 400 400 [| |] 0 400 400 % SCE_VISUALPROLOG_PLACEHOLDER (24) 0 400 400 {| |}:test 1 400 400 tmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pro0000664000175000017500000000225014773064066024163 0ustar gusnangusnan% SCE_VISUALPROLOG_KEY_MAJOR (1) goal % SCE_VISUALPROLOG_KEY_MINOR (2) procedure % SCE_VISUALPROLOG_KEY_DIRECTIVE (3) #include % SCE_VISUALPROLOG_COMMENT_BLOCK (4) /** SCE_VISUALPROLOG_COMMENT_KEY (6) @detail SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) @unknown /* SCE_VISUALPROLOG_IDENTIFIER (8) SCE_VISUALPROLOG_VARIABLE (9) SCE_VISUALPROLOG_ANONYMOUS (10) SCE_VISUALPROLOG_NUMBER (11) SCE_VISUALPROLOG_OPERATOR (12) */ */ lambda = { (A) = { (B, _discard) = A*B+1 } }. % SCE_VISUALPROLOG_COMMENT_LINE (5) % comment line % SCE_VISUALPROLOG_STRING_QUOTE (16) "" % SCE_VISUALPROLOG_STRING (20) "string" 'string' @"verbatim string" @[
] % SCE_VISUALPROLOG_STRING_ESCAPE (17) "\n" '\uAB12' % SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18) "\ " "open string % SCE_VISUALPROLOG_STRING_EOL (22) @#multi-line verbatim string# % SCE_VISUALPROLOG_EMBEDDED (23) [| |] % SCE_VISUALPROLOG_PLACEHOLDER (24) {| |}:test % line state & nesting [| {| /* % /* */ % */ [| {| @!string! % /* */ |} |] |} |] tmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pro.styled0000664000175000017500000000322314773064066025467 0ustar gusnangusnan{5}% SCE_VISUALPROLOG_KEY_MAJOR (1){0} {1}goal{0} {5}% SCE_VISUALPROLOG_KEY_MINOR (2){0} {2}procedure{0} {5}% SCE_VISUALPROLOG_KEY_DIRECTIVE (3){0} {3}#include{0} {5}% SCE_VISUALPROLOG_COMMENT_BLOCK (4){0} {4}/** SCE_VISUALPROLOG_COMMENT_KEY (6) {6}@detail{4} SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) {7}@unknown{4} /* SCE_VISUALPROLOG_IDENTIFIER (8) SCE_VISUALPROLOG_VARIABLE (9) SCE_VISUALPROLOG_ANONYMOUS (10) SCE_VISUALPROLOG_NUMBER (11) SCE_VISUALPROLOG_OPERATOR (12) */ */{0} {8}lambda{0} {12}={0} {12}{{0} {12}({9}A{12}){0} {12}={0} {12}{{0} {12}({9}B{12},{0} {10}_discard{12}){0} {12}={0} {9}A{12}*{9}B{12}+{11}1{0} {12}}{0} {12}}.{0} {5}% SCE_VISUALPROLOG_COMMENT_LINE (5){0} {5}% comment line{0} {5}% SCE_VISUALPROLOG_STRING_QUOTE (16){0} {16}""{0} {5}% SCE_VISUALPROLOG_STRING (20){0} {16}"{20}string{16}"{0} {16}'{20}string{16}'{0} {16}@"{20}verbatim string{16}"{0} {16}@[{20}
{16}]{0} {5}% SCE_VISUALPROLOG_STRING_ESCAPE (17){0} {16}"{17}\n{16}"{0} {16}'{17}\uAB12{16}'{0} {5}% SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18){0} {16}"{18}\ {16}"{0} {16}"{20}open string{18} {0} {5}% SCE_VISUALPROLOG_STRING_EOL (22){0} {16}@#{20}multi-line{22} {20} verbatim{22} {20} string{16}#{0} {5}% SCE_VISUALPROLOG_EMBEDDED (23){0} {23}[| |]{0} {5}% SCE_VISUALPROLOG_PLACEHOLDER (24){0} {24}{|{0} {24}|}:test{0} {5}% line state & nesting{0} {23}[| {24}{|{0} {4}/* % /* */ % */{0} {23}[| {24}{|{0} {16}@!{20}string{16}!{0} {5}%{0} {4}/* */{0} {24}|}{23} |]{0} {24}|}{23} |]{0} tmpok_q575y/lexilla/test/examples/visualprolog/AllStyles.pl.styled0000664000175000017500000000332514773064066025305 0ustar gusnangusnan{5}% SCE_VISUALPROLOG_KEY_MAJOR (1){0} {5}% No keywords in ISO/SWI-Prolog{0} {1}goal{0} {5}% SCE_VISUALPROLOG_KEY_MINOR (2){0} {5}% No minor keywords in ISO/SWI-Prolog{0} {2}procedure{0} {5}% SCE_VISUALPROLOG_KEY_DIRECTIVE (3){0} {5}% No directives in ISO/SWI-Prolog{0} {3}#include{0} {5}% SCE_VISUALPROLOG_COMMENT_BLOCK (4){0} {4}/** SCE_VISUALPROLOG_COMMENT_KEY (6) {6}@detail{4} SCE_VISUALPROLOG_COMMENT_KEY_ERROR (7) {7}@unknown{4} /* SCE_VISUALPROLOG_IDENTIFIER (8) SCE_VISUALPROLOG_VARIABLE (9) SCE_VISUALPROLOG_ANONYMOUS (10) SCE_VISUALPROLOG_NUMBER (11) SCE_VISUALPROLOG_OPERATOR (12) */ */{0} {8}singleton{0} {12}-->{0} {12}[{9}S{12}],{0} {12}{{0} {1}string_lower{12}({9}S{12},{0} {9}L{12}),{0} {1}atom_codes{12}({9}L{12},{0} {9}Bytes{12}),{0} {1}sort{12}({11}0{12},{0} {12}@=<,{0} {9}Bytes{12},{0} {12}[{11}95{12},{0} {10}_discard{12}]){0} {12}}.{0} {5}% SCE_VISUALPROLOG_COMMENT_LINE (5){0} {5}% comment line{0} {5}% SCE_VISUALPROLOG_STRING_QUOTE (16){0} {16}""{0} {5}% SCE_VISUALPROLOG_STRING (20){0} {16}"{20}string{16}"{0} {16}'{20}string{16}'{0} {5}% ISO Prolog back-quoted string{0} {16}`{20}string{16}`{0} {5}% SCE_VISUALPROLOG_STRING_ESCAPE (17){0} {16}"{17}\n{16}"{0} {16}'{17}\uAB12{16}'{0} {5}% SCE_VISUALPROLOG_STRING_ESCAPE_ERROR (18){0} {16}"{18}\ {16}"{0} {16}"{20}open string{18} {0} {5}% Not implemented for ISO/SWI-Prolog:{0} {12}@{16}"{20}verbatim string{16}"{0} {12}@[<{2}div{0} {1}class{12}={16}"{20}test{16}"{12}>]{0} {5}% SCE_VISUALPROLOG_STRING_EOL (22){0} {12}@{8}#multi{12}-{8}line{0} {8}verbatim{0} {8}string#{0} {5}% SCE_VISUALPROLOG_EMBEDDED (23){0} {23}[| |]{0} {5}% SCE_VISUALPROLOG_PLACEHOLDER (24){0} {24}{|{0} {24}|}:test{0} tmpok_q575y/lexilla/test/examples/props/0000775000175000017500000000000014773064066020143 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/props/example.session.folded0000664000175000017500000000055614773064066024445 0ustar gusnangusnan 0 400 0 # Default=0 0 400 0 a 1 400 0 0 400 0 # Comment=1 1 400 0 1 400 0 0 400 0 # Heading=2 2 400 0 + [heading] 1 401 0 | 1 401 0 | 0 401 0 | # Assignment=3 0 401 0 | = 1 401 0 | 0 401 0 | # Default Value=4 0 401 0 | @ 1 401 0 | 0 401 0 | # Key=5 0 401 0 | key= 1 401 0 | 0 401 0 | tmpok_q575y/lexilla/test/examples/props/Issue96Folding.props.folded0000664000175000017500000000021514773064066025234 0ustar gusnangusnan 0 400 0 ; comment 0 400 0 [empty section] 2 400 0 + [normal section] 0 401 0 | @=default 0 401 0 | key=value 0 401 0 | tmpok_q575y/lexilla/test/examples/props/Issue96Folding.props0000664000175000017500000000007714773064066024006 0ustar gusnangusnan; comment [empty section] [normal section] @=default key=value tmpok_q575y/lexilla/test/examples/props/example.session0000664000175000017500000000015214773064066023201 0ustar gusnangusnan# Default=0 a # Comment=1 # Heading=2 [heading] # Assignment=3 = # Default Value=4 @ # Key=5 key= tmpok_q575y/lexilla/test/examples/props/example.session.styled0000664000175000017500000000023514773064066024506 0ustar gusnangusnan{1}# Default=0 {0}a {1}# Comment=1 {0} {1}# Heading=2 {2}[heading] {0} {1}# Assignment=3 {3}={0} {1}# Default Value=4 {4}@{0} {1}# Key=5 {5}key{3}={0} tmpok_q575y/lexilla/test/examples/props/SciTE.properties0000664000175000017500000000006114773064066023225 0ustar gusnangusnanlexer.*.session=props lexer.*.props=props fold=1 tmpok_q575y/lexilla/test/examples/props/Issue96Folding.props.styled0000664000175000017500000000012414773064066025302 0ustar gusnangusnan{1}; comment {2}[empty section] [normal section] {4}@{0}=default {5}key{3}={0}value tmpok_q575y/lexilla/test/examples/cmake/0000775000175000017500000000000014773064066020060 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/cmake/Bug77_1.cmake0000664000175000017500000000027714773064066022203 0ustar gusnangusnanif(MSVC80) # 1 elseif(MSVC90) # 2 elseif(APPLE) # 3 else() # 4 endif() if(MSVC80) # 1 elseif(MSVC90) # 2 endif() if(MSVC80) # 1 else() # 2 endif() if(MSVC80) # 1 endif() tmpok_q575y/lexilla/test/examples/cmake/Bug77_0.cmake0000664000175000017500000000027714773064066022202 0ustar gusnangusnanif(MSVC80) # 1 elseif(MSVC90) # 2 elseif(APPLE) # 3 else() # 4 endif() if(MSVC80) # 1 elseif(MSVC90) # 2 endif() if(MSVC80) # 1 else() # 2 endif() if(MSVC80) # 1 endif() tmpok_q575y/lexilla/test/examples/cmake/Bug77_1.cmake.folded0000664000175000017500000000102114773064066023423 0ustar gusnangusnan 2 400 401 + if(MSVC80) 0 401 400 | # 1 2 400 401 + elseif(MSVC90) 0 401 400 | # 2 2 400 401 + elseif(APPLE) 0 401 400 | # 3 2 400 401 + else() 0 401 401 | # 4 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 400 | # 1 2 400 401 + elseif(MSVC90) 0 401 401 | # 2 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 400 | # 1 2 400 401 + else() 0 401 401 | # 2 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 401 | # 1 0 401 400 | endif() 0 400 400 tmpok_q575y/lexilla/test/examples/cmake/SciTE.properties0000664000175000017500000000016514773064066023147 0ustar gusnangusnanlexer.*.cmake=cmake keywords2.*.cmake=MSVC80 MSVC90 APPLE fold=1 fold.at.else=0 match Bug77_1.cmake fold.at.else=1 tmpok_q575y/lexilla/test/examples/cmake/Bug77_0.cmake.styled0000664000175000017500000000057214773064066023503 0ustar gusnangusnan{11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}elseif{0}({6}MSVC90{0}) {1}# 2{0} {11}elseif{0}({6}APPLE{0}) {1}# 3{0} {11}else{0}() {1}# 4{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}elseif{0}({6}MSVC90{0}) {1}# 2{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}else{0}() {1}# 2{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}endif{0}() tmpok_q575y/lexilla/test/examples/cmake/Bug77_1.cmake.styled0000664000175000017500000000057214773064066023504 0ustar gusnangusnan{11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}elseif{0}({6}MSVC90{0}) {1}# 2{0} {11}elseif{0}({6}APPLE{0}) {1}# 3{0} {11}else{0}() {1}# 4{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}elseif{0}({6}MSVC90{0}) {1}# 2{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}else{0}() {1}# 2{0} {11}endif{0}() {11}if{0}({6}MSVC80{0}) {1}# 1{0} {11}endif{0}() tmpok_q575y/lexilla/test/examples/cmake/Bug77_0.cmake.folded0000664000175000017500000000102114773064066023422 0ustar gusnangusnan 2 400 401 + if(MSVC80) 0 401 401 | # 1 0 401 401 | elseif(MSVC90) 0 401 401 | # 2 0 401 401 | elseif(APPLE) 0 401 401 | # 3 0 401 401 | else() 0 401 401 | # 4 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 401 | # 1 0 401 401 | elseif(MSVC90) 0 401 401 | # 2 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 401 | # 1 0 401 401 | else() 0 401 401 | # 2 0 401 400 | endif() 0 400 400 2 400 401 + if(MSVC80) 0 401 401 | # 1 0 401 400 | endif() 0 400 400 tmpok_q575y/lexilla/test/examples/lua/0000775000175000017500000000000014773064066017561 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/lua/AllStyles.lua.folded0000664000175000017500000000316114773064066023435 0ustar gusnangusnan 0 400 0 -- Enumerate all styles: 0 to 20 0 400 0 -- 3 (comment doc) is not currently produced by lexer 1 400 0 0 400 0 --[[ comment=1 ]] 1 400 0 0 400 0 --[[ whitespace=0 ]] 0 400 0 -- w 1 400 0 0 400 0 -- comment line=2 1 400 0 0 400 0 --- comment doc=3 0 400 0 -- still comment doc 1 400 0 0 400 0 -- still comment doc 0 400 0 3 -- comment doc broken only by code 1 400 0 0 400 0 -- number=4 0 400 0 37 1 400 0 0 400 0 -- keyword=5 0 400 0 local a 1 400 0 0 400 0 -- double-quoted-string=6 0 400 0 "str" 1 400 0 0 400 0 -- single-quoted-string=7 0 400 0 'str' 1 400 0 0 400 0 -- literal string=8 0 400 0 [[ literal ]] 1 400 0 0 400 0 -- unused preprocessor=9 0 400 0 $if 1 400 0 0 400 0 -- operator=10 0 400 0 * 1 400 0 0 400 0 -- identifier=11 0 400 0 identifier=1 1 400 0 0 400 0 -- string EOL=12 0 400 0 "unclosed 1 400 0 0 400 0 -- keyword 2=13 0 400 0 print 1 400 0 0 400 0 -- keyword 3=14 0 400 0 keyword3 1 400 0 0 400 0 -- keyword 4=15 0 400 0 keyword4 1 400 0 0 400 0 -- keyword 5=16 0 400 0 keyword5 1 400 0 0 400 0 -- keyword 6=17 0 400 0 keyword6 1 400 0 0 400 0 -- keyword 7=18 0 400 0 keyword7 1 400 0 0 400 0 -- keyword 8=19 0 400 0 keyword8 1 400 0 0 400 0 -- label=20 0 400 0 ::label:: 1 400 0 0 400 0 -- identifier substyles.11.1=128 0 400 0 moon 0 400 0 tmpok_q575y/lexilla/test/examples/lua/nonASCII242.lua.folded0000664000175000017500000000132714773064066023316 0ustar gusnangusnan 0 400 0 -- Tests behaviour with non-ASCII identifiers joined with '.' or ':' 0 400 0 输出æ é€‰æ‹©å¤¹:加入å­å¤¹("æ示"):加入å­å¤¹("输出"):加入å­å¤¹("æ示&输出"):加入å­å¤¹("Log") 0 400 0 支æŒåº“管ç†å™¨:ç½®åæ ‡(0,工具æ :å–高度() + 资æºæ é€‰æ‹©å¤¹:å–高度()):置宽高(分隔æ¡_X.x,分隔æ¡_Y:å–åæ ‡()):显示() 1 400 0 0 400 0 é¸æŠžã‚°ãƒªãƒƒãƒ—:ã«å‚加(10,"グリップ"):ã«å‚加("グリップ") 1 400 0 0 400 0 í´ë¦½ì„ íƒ:가입("ë ˆì´ë¸”") 0 400 0 δέλτα:ζήτα("δέλτα") 0 400 0 źdźbÅ‚o.krnÄ…brność(0) 0 400 0 ðŸ£ðŸ˜‚:💮("😂") 1 400 0 0 400 0 string:rep("ddf"):gsub("ddf","ffd") 0 400 0 tmpok_q575y/lexilla/test/examples/lua/folding.lua.folded0000664000175000017500000000223614773064066023145 0ustar gusnangusnan 2 400 0 + --[[ coding:UTF-8 0 401 0 | folding structure examples ]] 1 400 0 0 400 0 -- Use all the folding keywords: 0 400 0 -- do end function if repeat until while 2 400 0 + function first() 0 401 0 | -- Comment 2 401 0 + if op == "+" then 0 402 0 | r = a + b 0 402 0 | elseif op == "-" then 0 402 0 | r = a - b 0 402 0 | elseif op == "*" then 0 402 0 | r = a*b 0 402 0 | elseif op == "/" then 0 402 0 | r = a/b 0 402 0 | else 0 402 0 | error("invalid operation") 0 402 0 | end 1 401 0 | 2 401 0 + for i=1,10 do 0 402 0 | print(i) 0 402 0 | end 1 401 0 | 2 401 0 + while a[i] do 0 402 0 | print(a[i]) 0 402 0 | i = i + 1 0 402 0 | end 1 401 0 | 0 401 0 | -- print the first non-empty line 2 401 0 + repeat 0 402 0 | line = io.read() 0 402 0 | until line ~= "" 0 401 0 | print(line) 1 401 0 | 0 401 0 | end 1 400 0 0 400 0 -- { ... } folds 2 400 0 + markers = { 0 401 0 | 256, 0 401 0 | 128, 0 401 0 | } 0 400 0 tmpok_q575y/lexilla/test/examples/lua/Bug2205.lua.styled0000664000175000017500000000031114773064066022610 0ustar gusnangusnan{13}print{10}({6}"First"{10}){0} {1}--[[ Block comment start print("Second") --[[ Another block comment ]]{0} {13}print{10}({6}"Third. If run through an actual program, this will be executed."{10}){0} tmpok_q575y/lexilla/test/examples/lua/AllStyles.lua0000664000175000017500000000134314773064066022201 0ustar gusnangusnan-- Enumerate all styles: 0 to 20 -- 3 (comment doc) is not currently produced by lexer --[[ comment=1 ]] --[[ whitespace=0 ]] -- w -- comment line=2 --- comment doc=3 -- still comment doc -- still comment doc 3 -- comment doc broken only by code -- number=4 37 -- keyword=5 local a -- double-quoted-string=6 "str" -- single-quoted-string=7 'str' -- literal string=8 [[ literal ]] -- unused preprocessor=9 $if -- operator=10 * -- identifier=11 identifier=1 -- string EOL=12 "unclosed -- keyword 2=13 print -- keyword 3=14 keyword3 -- keyword 4=15 keyword4 -- keyword 5=16 keyword5 -- keyword 6=17 keyword6 -- keyword 7=18 keyword7 -- keyword 8=19 keyword8 -- label=20 ::label:: -- identifier substyles.11.1=128 moon tmpok_q575y/lexilla/test/examples/lua/nonASCII242.lua0000664000175000017500000000106114773064066022055 0ustar gusnangusnan-- Tests behaviour with non-ASCII identifiers joined with '.' or ':' 输出æ é€‰æ‹©å¤¹:加入å­å¤¹("æ示"):加入å­å¤¹("输出"):加入å­å¤¹("æ示&输出"):加入å­å¤¹("Log") 支æŒåº“管ç†å™¨:ç½®åæ ‡(0,工具æ :å–高度() + 资æºæ é€‰æ‹©å¤¹:å–高度()):置宽高(分隔æ¡_X.x,分隔æ¡_Y:å–åæ ‡()):显示() é¸æŠžã‚°ãƒªãƒƒãƒ—:ã«å‚加(10,"グリップ"):ã«å‚加("グリップ") í´ë¦½ì„ íƒ:가입("ë ˆì´ë¸”") δέλτα:ζήτα("δέλτα") źdźbÅ‚o.krnÄ…brność(0) ðŸ£ðŸ˜‚:💮("😂") string:rep("ddf"):gsub("ddf","ffd") tmpok_q575y/lexilla/test/examples/lua/x.lua.folded0000664000175000017500000000034014773064066021764 0ustar gusnangusnan 2 400 0 + --[[ coding:UTF-8 0 401 0 | comment ]] 2 400 0 + function first() 0 401 0 | ::é–‹:: 0 401 0 | -- Comment 0 401 0 | func(SCI_ANNOTATIONSETTEXT, 'a', 0, "LINE1") 0 401 0 | end 0 400 0 tmpok_q575y/lexilla/test/examples/lua/SciTE.properties0000664000175000017500000000050614773064066022647 0ustar gusnangusnanlexer.*.lua=lua keywords.*.lua=do else elseif end for function if local repeat then until while keywords2.*.lua=print keywords3.*.lua=keyword3 keywords4.*.lua=keyword4 keywords5.*.lua=keyword5 keywords6.*.lua=keyword6 keywords7.*.lua=keyword7 keywords8.*.lua=keyword8 substyles.lua.11=1 substylewords.11.1.*.lua=moon fold=1 tmpok_q575y/lexilla/test/examples/lua/AllStyles.lua.styled0000664000175000017500000000172314773064066023506 0ustar gusnangusnan{2}-- Enumerate all styles: 0 to 20 -- 3 (comment doc) is not currently produced by lexer {0} {1}--[[ comment=1 ]]{0} {1}--[[ whitespace=0 ]]{0} {2}-- w {0} {2}-- comment line=2 {0} {3}--- comment doc=3 -- still comment doc {0} {3}-- still comment doc {4}3{0} {2}-- comment doc broken only by code {0} {2}-- number=4 {4}37{0} {2}-- keyword=5 {5}local{0} {11}a{0} {2}-- double-quoted-string=6 {6}"str"{0} {2}-- single-quoted-string=7 {7}'str'{0} {2}-- literal string=8 {8}[[ literal ]]{0} {2}-- unused preprocessor=9 {9}$if {0} {2}-- operator=10 {10}*{0} {2}-- identifier=11 {11}identifier{10}={4}1{0} {2}-- string EOL=12 {12}"unclosed {0} {2}-- keyword 2=13 {13}print{0} {2}-- keyword 3=14 {14}keyword3{0} {2}-- keyword 4=15 {15}keyword4{0} {2}-- keyword 5=16 {16}keyword5{0} {2}-- keyword 6=17 {17}keyword6{0} {2}-- keyword 7=18 {18}keyword7{0} {2}-- keyword 8=19 {19}keyword8{0} {2}-- label=20 {20}::label::{0} {2}-- identifier substyles.11.1=128 {128}moon{0} tmpok_q575y/lexilla/test/examples/lua/folding.lua.styled0000664000175000017500000000234114773064066023211 0ustar gusnangusnan{1}--[[ coding:UTF-8 folding structure examples ]]{0} {2}-- Use all the folding keywords: -- do end function if repeat until while {5}function{0} {11}first{10}(){0} {2}-- Comment {0} {5}if{0} {11}op{0} {10}=={0} {6}"+"{0} {5}then{0} {11}r{0} {10}={0} {11}a{0} {10}+{0} {11}b{0} {5}elseif{0} {11}op{0} {10}=={0} {6}"-"{0} {5}then{0} {11}r{0} {10}={0} {11}a{0} {10}-{0} {11}b{0} {5}elseif{0} {11}op{0} {10}=={0} {6}"*"{0} {5}then{0} {11}r{0} {10}={0} {11}a{10}*{11}b{0} {5}elseif{0} {11}op{0} {10}=={0} {6}"/"{0} {5}then{0} {11}r{0} {10}={0} {11}a{10}/{11}b{0} {5}else{0} {11}error{10}({6}"invalid operation"{10}){0} {5}end{0} {5}for{0} {11}i{10}={4}1{10},{4}10{0} {5}do{0} {13}print{10}({11}i{10}){0} {5}end{0} {5}while{0} {11}a{10}[{11}i{10}]{0} {5}do{0} {13}print{10}({11}a{10}[{11}i{10}]){0} {11}i{0} {10}={0} {11}i{0} {10}+{0} {4}1{0} {5}end{0} {2}-- print the first non-empty line {0} {5}repeat{0} {11}line{0} {10}={0} {11}io.read{10}(){0} {5}until{0} {11}line{0} {10}~={0} {6}""{0} {13}print{10}({11}line{10}){0} {5}end{0} {2}-- { ... } folds {11}markers{0} {10}={0} {10}{{0} {4}256{10},{0} {4}128{10},{0} {10}}{0} tmpok_q575y/lexilla/test/examples/lua/nonASCII242.lua.styled0000664000175000017500000000152414773064066023364 0ustar gusnangusnan{2}-- Tests behaviour with non-ASCII identifiers joined with '.' or ':' {11}输出æ é€‰æ‹©å¤¹:加入å­å¤¹{10}({6}"æ示"{10}):{11}加入å­å¤¹{10}({6}"输出"{10}):{11}加入å­å¤¹{10}({6}"æ示&输出"{10}):{11}加入å­å¤¹{10}({6}"Log"{10}){0} {11}支æŒåº“管ç†å™¨:ç½®åæ ‡{10}({4}0{10},{11}工具æ :å–高度{10}(){0} {10}+{0} {11}资æºæ é€‰æ‹©å¤¹:å–高度{10}()):{11}置宽高{10}({11}分隔æ¡_X.x{10},{11}分隔æ¡_Y:å–åæ ‡{10}()):{11}显示{10}(){0} {11}é¸æŠžã‚°ãƒªãƒƒãƒ—:ã«å‚加{10}({4}10{10},{6}"グリップ"{10}):{11}ã«å‚加{10}({6}"グリップ"{10}){0} {11}í´ë¦½ì„ íƒ:가입{10}({6}"ë ˆì´ë¸”"{10}){0} {11}δέλτα:ζήτα{10}({6}"δέλτα"{10}){0} {11}źdźbÅ‚o.krnÄ…brność{10}({4}0{10}){0} {11}ðŸ£ðŸ˜‚:💮{10}({6}"😂"{10}){0} {11}string:rep{10}({6}"ddf"{10}):{11}gsub{10}({6}"ddf"{10},{6}"ffd"{10}){0} tmpok_q575y/lexilla/test/examples/lua/x.lua.styled0000664000175000017500000000032314773064066022034 0ustar gusnangusnan{1}--[[ coding:UTF-8 comment ]]{0} {5}function{0} {11}first{10}(){0} {20}::é–‹::{0} {2}-- Comment {0} {11}func{10}({11}SCI_ANNOTATIONSETTEXT{10},{0} {7}'a'{10},{0} {4}0{10},{0} {6}"LINE1"{10}){0} {5}end{0} tmpok_q575y/lexilla/test/examples/lua/x.lua0000664000175000017500000000017014773064066020531 0ustar gusnangusnan--[[ coding:UTF-8 comment ]] function first() ::é–‹:: -- Comment func(SCI_ANNOTATIONSETTEXT, 'a', 0, "LINE1") end tmpok_q575y/lexilla/test/examples/lua/folding.lua0000664000175000017500000000117414773064066021711 0ustar gusnangusnan--[[ coding:UTF-8 folding structure examples ]] -- Use all the folding keywords: -- do end function if repeat until while function first() -- Comment if op == "+" then r = a + b elseif op == "-" then r = a - b elseif op == "*" then r = a*b elseif op == "/" then r = a/b else error("invalid operation") end for i=1,10 do print(i) end while a[i] do print(a[i]) i = i + 1 end -- print the first non-empty line repeat line = io.read() until line ~= "" print(line) end -- { ... } folds markers = { 256, 128, } tmpok_q575y/lexilla/test/examples/lua/Bug2205.lua0000664000175000017500000000023714773064066021314 0ustar gusnangusnanprint("First") --[[ Block comment start print("Second") --[[ Another block comment ]] print("Third. If run through an actual program, this will be executed.") tmpok_q575y/lexilla/test/examples/lua/Bug2205.lua.folded0000664000175000017500000000035514773064066022551 0ustar gusnangusnan 0 400 0 print("First") 2 400 0 + --[[ Block comment start 0 401 0 | print("Second") 0 401 0 | --[[ Another block comment ]] 0 400 0 print("Third. If run through an actual program, this will be executed.") 0 400 0 tmpok_q575y/lexilla/test/examples/makefile/0000775000175000017500000000000014773064066020555 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/makefile/longline.mak0000664000175000017500000000215614773064066023062 0ustar gusnangusnan# makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line # Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 tmpok_q575y/lexilla/test/examples/makefile/longline.mak.styled0000664000175000017500000000217214773064066024363 0ustar gusnangusnan{1}# makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line {0} {1}# Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 {0} tmpok_q575y/lexilla/test/examples/makefile/SciTE.properties0000664000175000017500000000002514773064066023637 0ustar gusnangusnanlexer.*.mak=makefile tmpok_q575y/lexilla/test/examples/makefile/x.mak.folded0000664000175000017500000000070414773064066022753 0ustar gusnangusnan 0 400 0 # '# comment' comment=1 0 400 0 # comment 0 400 0 0 400 0 # '.SUFFIXES' target=5, ':' operator=4 0 400 0 .SUFFIXES: 0 400 0 0 400 0 # 'LD' identifier=3, '=' operator=4, 'link' default=0 0 400 0 LD=link 0 400 0 0 400 0 # '!IFDEF DEBUG' preprocessor=2 0 400 0 !IFDEF DEBUG 0 400 0 0 400 0 # '$(' ID EOL=9 0 400 0 X=$( 0 400 0 0 400 0 # End of file 0 400 0 tmpok_q575y/lexilla/test/examples/makefile/x.mak.styled0000664000175000017500000000044014773064066023017 0ustar gusnangusnan{1}# '# comment' comment=1 # comment {0} {1}# '.SUFFIXES' target=5, ':' operator=4 {5}.SUFFIXES{4}:{0} {1}# 'LD' identifier=3, '=' operator=4, 'link' default=0 {3}LD{4}={0}link {1}# '!IFDEF DEBUG' preprocessor=2 {2}!IFDEF DEBUG {0} {1}# '$(' ID EOL=9 {3}X{4}={9}$( {0} {1}# End of file tmpok_q575y/lexilla/test/examples/makefile/longline.mak.folded0000664000175000017500000000225714773064066024320 0ustar gusnangusnan 0 400 0 # makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line 0 400 0 0 400 0 # Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/makefile/x.mak0000664000175000017500000000034714773064066021522 0ustar gusnangusnan# '# comment' comment=1 # comment # '.SUFFIXES' target=5, ':' operator=4 .SUFFIXES: # 'LD' identifier=3, '=' operator=4, 'link' default=0 LD=link # '!IFDEF DEBUG' preprocessor=2 !IFDEF DEBUG # '$(' ID EOL=9 X=$( # End of file tmpok_q575y/lexilla/test/examples/tcl/0000775000175000017500000000000014773064066017562 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/tcl/x.tcl0000664000175000017500000000026214773064066020535 0ustar gusnangusnan# tcl tests #simple example proc Echo_Server {port} { set s [socket -server EchoAccept $port] vwait forever; } # Bug #1947 $s($i,"n") set n $showArray($i,"neighbor") tmpok_q575y/lexilla/test/examples/tcl/x.tcl.styled0000664000175000017500000000052414773064066022041 0ustar gusnangusnan{2}# tcl tests {0} {2}#simple example {0} {12}proc{0} {7}Echo_Server{0} {6}{{7}port{6}}{0} {6}{ {0} {12}set{0} {7}s{0} {6}[{12}socket{0} {10}-server{0} {7}EchoAccept{0} {8}$port{6}] {0} {12}vwait{0} {7}forever{0}; {6}} {0} {2}# Bug #1947 {0} {8}$s{6}({8}$i{6},{5}"n"{6}) {12}set{0} {7}n{0} {8}$showArray{6}({8}$i{6},{5}"neighbor"{6}) tmpok_q575y/lexilla/test/examples/tcl/SciTE.properties0000664000175000017500000000012314773064066022643 0ustar gusnangusnanlexer.*.tcl=tcl keywords.*.tcl=proc set socket vwait fold.comment=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/tcl/x.tcl.folded0000664000175000017500000000055014773064066021771 0ustar gusnangusnan 2 400 3 + # tcl tests 1 401 3 | 0 401 3 | #simple example 1 401 3 | 2 400 2 + proc Echo_Server {port} { 0 401 2 | set s [socket -server EchoAccept $port] 0 401 2 | vwait forever; 0 401 0 | } 1 400 0 2 400 3 + # Bug #1947 1 401 3 | 0 400 0 $s($i,"n") 0 400 0 set n $showArray($i,"neighbor") 1 400 0 tmpok_q575y/lexilla/test/examples/x12/0000775000175000017500000000000014773064066017412 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/x12/empty.x12.styled0000664000175000017500000000036214773064066022410 0ustar gusnangusnan{2}ISA{7}*{0}00{7}*{0} {7}*{0}00{7}*{0} {7}*{0}01{7}*{0}0011223456 {7}*{0}01{7}*{0}999999999 {7}*{0}950120{7}*{0}0147{7}*{0}U{7}*{0}00300{7}*{0}000000007{7}*{0}0{7}*{0}P{7}*{8}~{6} {2}IEA{7}*{0}2{7}*{0}000000007{6} tmpok_q575y/lexilla/test/examples/x12/x.x120000664000175000017500000000153214773064066020216 0ustar gusnangusnanISA*00* *00* *01*0011223456 *01*999999999 *950120*0147*U*00300*000000007*0*P*~ GS*PO*0011223456*999999999*950120*0147*5*X*003040 ST*850*000000001 BEG*00*SA*95018017***950118 N1*SE*UNIVERSAL WIDGETS N3*375 PLYMOUTH PARK*SUITE 205 N4*IRVING*TX*75061 PO1*001*4*EA*330*TE*IN*525*VN*X357-W2 PID*F****HIGH PERFORMANCE WIDGET SCH*4*EA****002*950322 CTT*1*1 SE*10*000000001 ST*850*000000002 BEG*00*SA*95018017***950118 N1*SE*UNIVERSAL WIDGETS PID*F****HIGH PERFORMANCE WIDGET SCH*4*EA****002*950322 CTT*1*1 SE*7*000000002 GE*2*5 GS*PO*0011223456*999999999*950120*0147*6*X*003040 ST*850*000000003 BEG*00*SA*95018017***950118 N1*SE*UNIVERSAL WIDGETS N3*375 PLYMOUTH PARK*SUITE 205 N4*IRVING*TX*75061 PO1*001*4*EA*330*TE*IN*525*VN*X357-W2 PID*F****HIGH PERFORMANCE WIDGET SCH*4*EA****002*950322 CTT*1*1 SE*10*000000003 GE*1*6 IEA*2*000000007 tmpok_q575y/lexilla/test/examples/x12/empty.x120000664000175000017500000000017214773064066021104 0ustar gusnangusnanISA*00* *00* *01*0011223456 *01*999999999 *950120*0147*U*00300*000000007*0*P*~ IEA*2*000000007 tmpok_q575y/lexilla/test/examples/x12/SciTE.properties0000664000175000017500000000003014773064066022470 0ustar gusnangusnanlexer.*.x12=x12 fold=1 tmpok_q575y/lexilla/test/examples/x12/x.x12.folded0000664000175000017500000000242414773064066021453 0ustar gusnangusnan 2 400 0 + ISA*00* *00* *01*0011223456 *01*999999999 *950120*0147*U*00300*000000007*0*P*~ 2 401 0 + GS*PO*0011223456*999999999*950120*0147*5*X*003040 2 402 0 + ST*850*000000001 0 403 0 | BEG*00*SA*95018017***950118 0 403 0 | N1*SE*UNIVERSAL WIDGETS 0 403 0 | N3*375 PLYMOUTH PARK*SUITE 205 0 403 0 | N4*IRVING*TX*75061 0 403 0 | PO1*001*4*EA*330*TE*IN*525*VN*X357-W2 0 403 0 | PID*F****HIGH PERFORMANCE WIDGET 0 403 0 | SCH*4*EA****002*950322 0 403 0 | CTT*1*1 0 403 0 | SE*10*000000001 2 402 0 + ST*850*000000002 0 403 0 | BEG*00*SA*95018017***950118 0 403 0 | N1*SE*UNIVERSAL WIDGETS 0 403 0 | PID*F****HIGH PERFORMANCE WIDGET 0 403 0 | SCH*4*EA****002*950322 0 403 0 | CTT*1*1 0 403 0 | SE*7*000000002 0 402 0 | GE*2*5 2 401 0 + GS*PO*0011223456*999999999*950120*0147*6*X*003040 2 402 0 + ST*850*000000003 0 403 0 | BEG*00*SA*95018017***950118 0 403 0 | N1*SE*UNIVERSAL WIDGETS 0 403 0 | N3*375 PLYMOUTH PARK*SUITE 205 0 403 0 | N4*IRVING*TX*75061 0 403 0 | PO1*001*4*EA*330*TE*IN*525*VN*X357-W2 0 403 0 | PID*F****HIGH PERFORMANCE WIDGET 0 403 0 | SCH*4*EA****002*950322 0 403 0 | CTT*1*1 0 403 0 | SE*10*000000003 0 402 0 | GE*1*6 0 401 0 | IEA*2*000000007 0 400 0 tmpok_q575y/lexilla/test/examples/x12/x.x12.styled0000664000175000017500000000336014773064066021522 0ustar gusnangusnan{2}ISA{7}*{0}00{7}*{0} {7}*{0}00{7}*{0} {7}*{0}01{7}*{0}0011223456 {7}*{0}01{7}*{0}999999999 {7}*{0}950120{7}*{0}0147{7}*{0}U{7}*{0}00300{7}*{0}000000007{7}*{0}0{7}*{0}P{7}*{8}~{6} {3}GS{7}*{0}PO{7}*{0}0011223456{7}*{0}999999999{7}*{0}950120{7}*{0}0147{7}*{0}5{7}*{0}X{7}*{0}003040{6} {4}ST{7}*{0}850{7}*{0}000000001{6} {5}BEG{7}*{0}00{7}*{0}SA{7}*{0}95018017{7}***{0}950118{6} {5}N1{7}*{0}SE{7}*{0}UNIVERSAL WIDGETS{6} {5}N3{7}*{0}375 PLYMOUTH PARK{7}*{0}SUITE 205{6} {5}N4{7}*{0}IRVING{7}*{0}TX{7}*{0}75061{6} {5}PO1{7}*{0}001{7}*{0}4{7}*{0}EA{7}*{0}330{7}*{0}TE{7}*{0}IN{7}*{0}525{7}*{0}VN{7}*{0}X357-W2{6} {5}PID{7}*{0}F{7}****{0}HIGH PERFORMANCE WIDGET{6} {5}SCH{7}*{0}4{7}*{0}EA{7}****{0}002{7}*{0}950322{6} {5}CTT{7}*{0}1{7}*{0}1{6} {4}SE{7}*{0}10{7}*{0}000000001{6} {4}ST{7}*{0}850{7}*{0}000000002{6} {5}BEG{7}*{0}00{7}*{0}SA{7}*{0}95018017{7}***{0}950118{6} {5}N1{7}*{0}SE{7}*{0}UNIVERSAL WIDGETS{6} {5}PID{7}*{0}F{7}****{0}HIGH PERFORMANCE WIDGET{6} {5}SCH{7}*{0}4{7}*{0}EA{7}****{0}002{7}*{0}950322{6} {5}CTT{7}*{0}1{7}*{0}1{6} {4}SE{7}*{0}7{7}*{0}000000002{6} {3}GE{7}*{0}2{7}*{0}5{6} {3}GS{7}*{0}PO{7}*{0}0011223456{7}*{0}999999999{7}*{0}950120{7}*{0}0147{7}*{0}6{7}*{0}X{7}*{0}003040{6} {4}ST{7}*{0}850{7}*{0}000000003{6} {5}BEG{7}*{0}00{7}*{0}SA{7}*{0}95018017{7}***{0}950118{6} {5}N1{7}*{0}SE{7}*{0}UNIVERSAL WIDGETS{6} {5}N3{7}*{0}375 PLYMOUTH PARK{7}*{0}SUITE 205{6} {5}N4{7}*{0}IRVING{7}*{0}TX{7}*{0}75061{6} {5}PO1{7}*{0}001{7}*{0}4{7}*{0}EA{7}*{0}330{7}*{0}TE{7}*{0}IN{7}*{0}525{7}*{0}VN{7}*{0}X357-W2{6} {5}PID{7}*{0}F{7}****{0}HIGH PERFORMANCE WIDGET{6} {5}SCH{7}*{0}4{7}*{0}EA{7}****{0}002{7}*{0}950322{6} {5}CTT{7}*{0}1{7}*{0}1{6} {4}SE{7}*{0}10{7}*{0}000000003{6} {3}GE{7}*{0}1{7}*{0}6{6} {2}IEA{7}*{0}2{7}*{0}000000007{6} tmpok_q575y/lexilla/test/examples/x12/empty.x12.folded0000664000175000017500000000024114773064066022335 0ustar gusnangusnan 2 400 0 + ISA*00* *00* *01*0011223456 *01*999999999 *950120*0147*U*00300*000000007*0*P*~ 0 401 0 | IEA*2*000000007 0 400 0 tmpok_q575y/lexilla/test/examples/troff/0000775000175000017500000000000014773064066020120 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/troff/AllStyles.roff.styled0000664000175000017500000000236714773064066024225 0ustar gusnangusnan{1}.tm{0} Hello world "FOO" {1}.if{0} 'foo'b a r'{1} .if{0} {3}23{2} .FOO{0} {3}2332{0} {5}"hell{10}\fB{5}o{10}\fP{5}"{0} {13}\ {0} foo {5}"Hello world"{0} {1}.if{0} ({3}1{0} + {3}1{0}){1} .nop .if{0} {3}1{0} {13}\ {1} .tm{0} Bar {1}.if{0} {3}23{0}+{3}1{0} {13}\ {1} .tm{0} Bar {1}.if{0} {3}1{0} {4}\{{13}\ {1}. tm{0} TEST {1}. tm{0} FOO {4}.\} {1}. {6}.\" Hello world {1}.if{0} {3}0{0} {4}\{{13}\ {1}. tm{0} Bar {1}. tm{0} sffsdf{4}\}{0} {6}\# Hello world {1}.tm{0} End {1}.ig {0}ig {7}This is \fBignored\fP. This line as well. {1}.ig{0} {7}.tm Hello world {1}..{0} {1}. .de{0} Macro END {2}. FOO{0} {2}.END{0} {8}\*[FOO*\[hello]fdsf]{0}sdfsdf {2}.END{0} {9}\$1{0} {6}\" will never be met in the wild... {10}\f[BI]{0}Hello world{10}\fP{0} {11}\na{0}-{11}\n(ab{0}-{11}\n[ab]{0}- {12}\m[green]{0}green text{12}\m[]{0} {13}\(lq{0}quoted text{13}\(rq{0} $PATH={14}\V[PATH]{0} {15}\O0{0}test {16}\s0{0}small{16}\s+1{0}larger{16}\s+[100]{0}very large{16}\s-'100'{0}smaller {17}\!transparent \fBline\fP {0}transparent{17}\?embed\?{0} {18}\A'id'{0} {19}\D'c 10'{0} {19}\l'10c'{0} {19}\L'10c'{0} {20}\h'12c'{0} {20}\v'4'{0} {21}\H@23@{0} {22}\o#abc#{0} {23}\S'45'{0} {24}\w'width of'{0} {25}\x'1'{0} {26}\X'device control'{0} {26}\Y[foo]{0} {27}\Z"No move"{0} {27}\zN{0} tmpok_q575y/lexilla/test/examples/troff/AllStyles.roff0000664000175000017500000000137414773064066022717 0ustar gusnangusnan.tm Hello world "FOO" .if 'foo'b a r' .if 23 .FOO 2332 "hell\fBo\fP" \ foo "Hello world" .if (1 + 1) .nop .if 1 \ .tm Bar .if 23+1 \ .tm Bar .if 1 \{\ . tm TEST . tm FOO .\} . .\" Hello world .if 0 \{\ . tm Bar . tm sffsdf\} \# Hello world .tm End .ig ig This is \fBignored\fP. This line as well. .ig .tm Hello world .. . .de Macro END . FOO .END \*[FOO*\[hello]fdsf]sdfsdf .END \$1 \" will never be met in the wild... \f[BI]Hello world\fP \na-\n(ab-\n[ab]- \m[green]green text\m[] \(lqquoted text\(rq $PATH=\V[PATH] \O0test \s0small\s+1larger\s+[100]very large\s-'100'smaller \!transparent \fBline\fP transparent\?embed\? \A'id' \D'c 10' \l'10c' \L'10c' \h'12c' \v'4' \H@23@ \o#abc# \S'45' \w'width of' \x'1' \X'device control' \Y[foo] \Z"No move" \zN tmpok_q575y/lexilla/test/examples/troff/SciTE.properties0000664000175000017500000000226114773064066023206 0ustar gusnangusnanlexer.*.roff=troff # Predefined requests keywords.*.roff= \ ab ad af aln als am am1 ami ami1 as as1 asciify \ backtrace bd blm box boxa bp br brp break \ c2 cc ce cf cflags ch char chop class close color composite continue cp cs cu \ da de de1 defcolor dei dei1 device devicem di do ds ds1 dt \ ec ecr ecs el em eo ev evc ex \ fam fc fchar fcolor fi fl fp fschar fspecial ft ftr fzoom \ gcolor \ hc hcode hla hlm hpf hpfa hpfcode hw hy hym hys \ ie if ig . in it itc \ kern \ lc length linetabs linetabs lf lg ll lsm ls lt \ mc mk mso \ na ne nf nh nm nn nop nr nroff ns nx \ open opena os output \ pc pev pi pl pm pn pnr po ps psbb pso ptr pvs pvs \ rchar rd return rfschar rj rm rn rnn rr rs rt \ schar shc shift sizes so sp special spreadwarn ss sty substring sv sy \ ta tc ti tkf tl tm tm1 tmc tr trf trin trnt troff \ uf ul unformat \ vpt vs \ warn warnscale wh while write writec writem # Flow control requests/commands with conditionals keywords2.*.roff=if ie while # Flow control requests/commands without conditionals keywords3.*.roff=el nop # Requests and commands, initiating ignore blocks keywords4.*.roff=ig # Requests and commands with end-macros keywords5.*.roff=am am1 de de1 fold=1 tmpok_q575y/lexilla/test/examples/troff/AllStyles.roff.folded0000664000175000017500000000265514773064066024156 0ustar gusnangusnan 0 400 0 .tm Hello world "FOO" 0 400 0 .if 'foo'b a r' .if 23 .FOO 2332 "hell\fBo\fP" \ 0 400 0 foo "Hello world" 0 400 0 .if (1 + 1) .nop 0 400 0 .if 1 \ 0 400 0 .tm Bar 0 400 0 .if 23+1 \ 0 400 0 .tm Bar 2 400 0 + .if 1 \{\ 0 401 0 | . tm TEST 0 401 0 | . tm FOO 0 401 0 | .\} 1 400 0 . 0 400 0 .\" Hello world 2 400 0 + .if 0 \{\ 0 401 0 | . tm Bar 0 401 0 | . tm sffsdf\} 0 400 0 \# Hello world 0 400 0 .tm End 2 400 0 + .ig ig 0 401 0 | This is \fBignored\fP. 0 401 0 | 0 401 0 | This line as well. 2 400 0 + .ig 0 401 0 | .tm Hello world 0 400 0 .. 1 400 0 . 2 400 0 + .de Macro END 0 401 0 | . FOO 0 401 0 | .END 0 400 0 \*[FOO*\[hello]fdsf]sdfsdf 0 400 0 .END 0 400 0 \$1 \" will never be met in the wild... 0 400 0 \f[BI]Hello world\fP 0 400 0 \na-\n(ab-\n[ab]- 0 400 0 \m[green]green text\m[] 0 400 0 \(lqquoted text\(rq 0 400 0 $PATH=\V[PATH] 0 400 0 \O0test 0 400 0 \s0small\s+1larger\s+[100]very large\s-'100'smaller 0 400 0 \!transparent \fBline\fP 0 400 0 transparent\?embed\? 0 400 0 \A'id' 0 400 0 \D'c 10' \l'10c' \L'10c' 0 400 0 \h'12c' \v'4' 0 400 0 \H@23@ 0 400 0 \o#abc# 0 400 0 \S'45' 0 400 0 \w'width of' 0 400 0 \x'1' 0 400 0 \X'device control' \Y[foo] 0 400 0 \Z"No move" \zN 0 400 0 tmpok_q575y/lexilla/test/examples/raku/0000775000175000017500000000000014773064066017742 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/raku/SciTE.properties0000664000175000017500000001657414773064066023044 0ustar gusnangusnanlexer.*.p6=raku # Keywords (base) keywords.*.p6=BEGIN CATCH CHECK CONTROL END ENTER EVAL FIRST \ INIT KEEP LAST LEAVE NEXT POST PRE START TEMP UNDO after also andthen as \ async augment bag before but category circumfix class cmp complex constant \ contend default defer div does dynamic else elsif enum eq eqv extra fail \ fatal ff fff for gather gcd ge given grammar gt handles has if infix is lcm \ le leave leg let lift loop lt macro make maybe method mix mod module multi \ ne not o only oo or orelse orwith postcircumfix postfix prefix proto regex \ repeat require return-rw returns role rule size_t slang start str submethod \ subset supersede take temp term token trusts try unit unless until when \ where while with without x xor xx # Keywords (functions) keywords2.*.p6=ACCEPTS AT-KEY EVALFILE EXISTS-KEY Filetests \ IO STORE abs accept acos acosec acosech acosh acotan acotanh alarm and \ antipairs asec asech asin asinh atan atan2 atanh base bind binmode bless \ break caller ceiling chars chdir chmod chomp chop chr chroot chrs cis close \ closedir codes comb conj connect contains continue cos cosec cosech cosh \ cotan cotanh crypt dbm defined die do dump each elems eof exec exists exit \ exp expmod fc fcntl fileno flat flip flock floor fmt fork formats functions \ get getc getpeername getpgrp getppid getpriority getsock gist glob gmtime \ goto grep hyper import index int invert ioctl is-prime iterator join keyof \ keys kill kv last lazy lc lcfirst lines link list listen local localtime \ lock log log10 lsb lstat map match mkdir msb msg my narrow new next no of \ open ord ords our pack package pairs path pick pipe polymod pop pos pred \ print printf prototype push quoting race rand read readdir readline readlink \ readpipe recv redo ref rename requires reset return reverse rewinddir rindex \ rmdir roots round samecase say scalar sec sech seek seekdir select semctl \ semget semop send set setpgrp setpriority setsockopt shift shm shutdown sign \ sin sinh sleep sockets sort splice split sprintf sqrt srand stat state study \ sub subst substr substr-rw succ symlink sys syscall system syswrite tan tanh \ tc tclc tell telldir tie time times trans trim trim-leading trim-trailing \ truncate uc ucfirst unimatch uniname uninames uniprop uniprops unival unlink \ unpack unpolar unshift untie use utime values wait waitpid wantarray warn \ wordcase words write # Keywords (types) keywords3.*.p6=AST Any Block Bool CallFrame Callable Code \ Collation Compiler Complex ComplexStr Cool CurrentThreadScheduler Date \ DateTime Dateish Distribution Distribution::Hash Distribution::Locally \ Distribution::Path Duration Encoding Encoding::Registry Endian FatRat \ ForeignCode HyperSeq HyperWhatever Instant Int IntStr Junction Label \ Lock::Async Macro Method Mu Nil Num NumStr Numeric ObjAt Parameter Perl \ PredictiveIterator Proxy RaceSeq Rat RatStr Rational Real Routine \ Routine::WrapHandle Scalar Sequence Signature Str StrDistance Stringy Sub \ Submethod Telemetry Telemetry::Instrument::Thread \ Telemetry::Instrument::ThreadPool Telemetry::Instrument::Usage \ Telemetry::Period Telemetry::Sampler UInt ValueObjAt Variable Version \ Whatever WhateverCode atomicint bit bool buf buf1 buf16 buf2 buf32 buf4 \ buf64 buf8 int int1 int16 int2 int32 int4 int64 int8 long longlong num \ num32 num64 rat rat1 rat16 rat2 rat32 rat4 rat64 rat8 uint uint1 uint16 \ uint2 uint32 uint4 uint64 uint8 utf16 utf32 utf8 # Keywords (types composite) keywords4.*.p6=Array Associative Bag BagHash Baggy Blob Buf \ Capture Enumeration Hash Iterable Iterator List Map Mix MixHash Mixy NFC NFD \ NFKC NFKD Pair Positional PositionalBindFailover PseudoStash QuantHash Range \ Seq Set SetHash Setty Slip Stash Uni utf8 # Keywords (types domain specific) keywords5.*.p6=Attribute Cancellation Channel CompUnit \ CompUnit::Repository CompUnit::Repository::FileSystem \ CompUnit::Repository::Installation Distro Grammar IO IO::ArgFiles \ IO::CatHandle IO::Handle IO::Notification IO::Path IO::Path::Cygwin \ IO::Path::QNX IO::Path::Unix IO::Path::Win32 IO::Pipe IO::Socket \ IO::Socket::Async IO::Socket::INET IO::Spec IO::Spec::Cygwin \ IO::Spec::QNX IO::Spec::Unix IO::Spec::Win32 IO::Special Kernel Lock \ Match Order Pod::Block Pod::Block::Code Pod::Block::Comment \ Pod::Block::Declarator Pod::Block::Named Pod::Block::Para Pod::Block::Table \ Pod::Defn Pod::FormattingCode Pod::Heading Pod::Item Proc Proc::Async \ Promise Regex Scheduler Semaphore Supplier Supplier::Preserving Supply \ Systemic Tap Thread ThreadPoolScheduler VM # Keywords (types domain exceptions) keywords6.*.p6=Backtrace Backtrace::Frame CX::Done CX::Emit \ CX::Last CX::Next CX::Proceed CX::Redo CX::Return CX::Succeed CX::Take \ CX::Warn Exception Failure X::AdHoc X::Anon::Augment X::Anon::Multi \ X::Assignment::RO X::Attribute::NoPackage X::Attribute::Package \ X::Attribute::Required X::Attribute::Undeclared X::Augment::NoSuchType \ X::Bind X::Bind::NativeType X::Bind::Slice X::Caller::NotDynamic \ X::Channel::ReceiveOnClosed X::Channel::SendOnClosed X::Comp \ X::Composition::NotComposable X::Constructor::Positional X::Control \ X::ControlFlow X::ControlFlow::Return X::DateTime::TimezoneClash \ X::Declaration::Scope X::Declaration::Scope::Multi X::Does::TypeObject \ X::Dynamic::NotFound X::Eval::NoSuchLang X::Export::NameClash X::IO \ X::IO::Chdir X::IO::Chmod X::IO::Copy X::IO::Cwd X::IO::Dir X::IO::DoesNotExist \ X::IO::Link X::IO::Mkdir X::IO::Move X::IO::Rename X::IO::Rmdir \ X::IO::Symlink X::IO::Unlink X::Inheritance::NotComposed \ X::Inheritance::Unsupported X::Method::InvalidQualifier X::Method::NotFound \ X::Method::Private::Permission X::Method::Private::Unqualified \ X::Mixin::NotComposable X::NYI X::NoDispatcher X::Numeric::Real \ X::OS X::Obsolete X::OutOfRange X::Package::Stubbed X::Parameter::Default \ X::Parameter::MultipleTypeConstraints X::Parameter::Placeholder \ X::Parameter::Twigil X::Parameter::WrongOrder X::Phaser::Multiple \ X::Phaser::PrePost X::Placeholder::Block X::Placeholder::Mainline \ X::Pod X::Proc::Async X::Proc::Async::AlreadyStarted X::Proc::Async::BindOrUse \ X::Proc::Async::CharsOrBytes X::Proc::Async::MustBeStarted \ X::Proc::Async::OpenForWriting X::Proc::Async::TapBeforeSpawn \ X::Proc::Unsuccessful X::Promise::CauseOnlyValidOnBroken X::Promise::Vowed \ X::Redeclaration X::Role::Initialization X::Scheduler::CueInNaNSeconds \ X::Seq::Consumed X::Sequence::Deduction X::Signature::NameClash \ X::Signature::Placeholder X::Str::Numeric X::StubCode X::Syntax \ X::Syntax::Augment::WithoutMonkeyTyping X::Syntax::Comment::Embedded \ X::Syntax::Confused X::Syntax::InfixInTermPosition X::Syntax::Malformed \ X::Syntax::Missing X::Syntax::NegatedPair X::Syntax::NoSelf \ X::Syntax::Number::RadixOutOfRange X::Syntax::P5 X::Syntax::Perl5Var \ X::Syntax::Regex::Adverb X::Syntax::Regex::SolitaryQuantifier \ X::Syntax::Reserved X::Syntax::Self::WithoutObject \ X::Syntax::Signature::InvocantMarker X::Syntax::Term::MissingInitializer \ X::Syntax::UnlessElse X::Syntax::Variable::Match X::Syntax::Variable::Numeric \ X::Syntax::Variable::Twigil X::Temporal X::Temporal::InvalidFormat \ X::TypeCheck X::TypeCheck::Assignment X::TypeCheck::Binding \ X::TypeCheck::Return X::TypeCheck::Splice X::Undeclared # Keywords (adverbs) keywords7.*.p6=D a array b backslash c closure delete double \ exec exists f function h hash heredoc k kv p q qq quotewords s scalar single \ sym to v val w words ww x fold.compact=1 tmpok_q575y/lexilla/test/examples/raku/x.p60000664000175000017500000000206014773064066020456 0ustar gusnangusnanuse v6; # Normal single line comment my Int $i = 0; my Rat $r = 3.142; my Str $backslash = "\\"; my Str $s = "Hello, world! \$i == $i and \$r == $r"; say $s; #`{{ *** This is a multi-line comment *** }} my @array = #`[[ inline comment ]] ; my %hash = ( AAA => 1, BBB => 2 ); say q[This back\slash stays]; say q[This back\\slash stays]; # Identical output say Q:q!Just a literal "\n" here!; =begin pod POD Documentation... =end pod say qq:to/END/; A multi-line string with interpolated vars: $i, $r END sub function { return q:to/END/; Here is some multi-line string END } my $func = &function; say $func(); grammar Calculator { token TOP { } proto rule calc-op {*} rule calc-op:sym { '+' } rule calc-op:sym { '-' } token num { \d+ } } class Calculations { method TOP ($/) { make $.made; } method calc-op:sym ($/) { make [+] $; } method calc-op:sym ($/) { make [-] $; } } say Calculator.parse('2 + 3', actions => Calculations).made; tmpok_q575y/lexilla/test/examples/raku/x.p6.styled0000664000175000017500000000416514773064066021771 0ustar gusnangusnan{20}use{0} {16}v6{18};{0} {2}# Normal single line comment{0} {20}my{0} {22}Int{0} {23}$i{0} {18}={0} {16}0{18};{0} {20}my{0} {22}Rat{0} {23}$r{0} {18}={0} {16}3.142{18};{0} {20}my{0} {22}Str{0} {23}$backslash{0} {18}={0} {8}"\\"{18};{0} {20}my{0} {22}Str{0} {23}$s{0} {18}={0} {8}"Hello, world! \$i == {12}$i{8} and \$r == {12}$r{8}"{18};{0} {20}say{0} {23}$s{18};{0} {2}#`{3}{{ *** This is a multi-line comment *** }}{0} {20}my{0} {24}@array{0} {18}={0} {2}#`{3}[[ inline comment ]]{0} {9}{18};{0} {20}my{0} {25}%hash{0} {18}={0} {18}({0} {21}AAA{0} {18}=>{0} {16}1{18},{0} {21}BBB{0} {18}=>{0} {16}2{0} {18});{0} {20}say{0} {9}q[This back\slash stays]{18};{0} {20}say{0} {9}q[This back\\slash stays]{18};{0} {2}# Identical output{0} {20}say{0} {11}Q{15}:q{11}!Just a literal "\n" here!{18};{0} {4}=begin pod POD Documentation... =end pod{0} {20}say{0} {10}qq{15}:to{10}/END/{18};{0} {7}A multi-line string with interpolated vars: {12}$i{7}, {12}$r{7} END{0} {20}sub{0} {21}function{0} {18}{{0} {20}return{0} {9}q{15}:to{9}/END/{18};{0} {6}Here is some multi-line string END{0} {18}}{0} {20}my{0} {23}$func{0} {18}={0} {26}&function{18};{0} {20}say{0} {23}$func{18}();{0} {19}grammar{0} {27}Calculator{0} {18}{{0} {19}token{0} {21}TOP{0} {13}{ }{0} {19}proto{0} {19}rule{0} {21}calc-op{0} {13}{*}{0} {19}rule{0} {21}calc-op{15}:sym{18}<{21}add{18}>{0} {13}{ '+' }{0} {19}rule{0} {21}calc-op{15}:sym{18}<{21}sub{18}>{0} {13}{ '-' }{0} {19}token{0} {21}num{0} {13}{ \d+ }{0} {18}}{0} {19}class{0} {28}Calculations{0} {18}{{0} {19}method{0} {21}TOP{0} {18}({23}$/{18}){0} {18}{{0} {19}make{0} {23}${18}<{23}calc-op{18}>.{21}made{18};{0} {18}}{0} {19}method{0} {21}calc-op{15}:sym{18}<{21}add{18}>{0} {18}({23}$/{18}){0} {18}{{0} {21}make{0} {18}[+]{0} {23}${18}<{23}num{18}>;{0} {18}}{0} {19}method{0} {21}calc-op{15}:sym{18}<{21}sub{18}>{0} {18}({23}$/{18}){0} {18}{{0} {21}make{0} {18}[-]{0} {23}${18}<{23}num{18}>;{0} {18}}{0} {18}}{0} {20}say{0} {21}Calculator{18}.{21}parse{18}({8}'2 + 3'{18},{0} {21}actions{0} {18}=>{0} {21}Calculations{18}).{21}made{18};{0} tmpok_q575y/lexilla/test/examples/raku/x.p6.folded0000664000175000017500000000341014773064066021712 0ustar gusnangusnan 0 400 400 use v6; 1 400 400 0 400 400 # Normal single line comment 0 400 400 my Int $i = 0; 0 400 400 my Rat $r = 3.142; 0 400 400 my Str $backslash = "\\"; 0 400 400 my Str $s = "Hello, world! \$i == $i and \$r == $r"; 0 400 400 say $s; 1 400 400 2 400 401 + #`{{ 0 401 401 | *** This is a multi-line comment *** 0 401 400 | }} 1 400 400 0 400 400 my @array = #`[[ inline comment ]] ; 0 400 400 my %hash = ( AAA => 1, BBB => 2 ); 1 400 400 0 400 400 say q[This back\slash stays]; 0 400 400 say q[This back\\slash stays]; # Identical output 0 400 400 say Q:q!Just a literal "\n" here!; 1 400 400 2 400 401 + =begin pod 0 401 401 | POD Documentation... 0 401 400 | =end pod 1 400 400 0 400 400 say qq:to/END/; 0 400 400 A multi-line 0 400 400 string with interpolated vars: $i, $r 0 400 400 END 1 400 400 2 400 401 + sub function { 0 401 401 | return q:to/END/; 0 401 401 | Here is 0 401 401 | some multi-line 0 401 401 | string 0 401 401 | END 0 401 400 | } 1 400 400 0 400 400 my $func = &function; 0 400 400 say $func(); 1 400 400 2 400 401 + grammar Calculator { 0 401 401 | token TOP { } 0 401 401 | proto rule calc-op {*} 0 401 401 | rule calc-op:sym { '+' } 0 401 401 | rule calc-op:sym { '-' } 0 401 401 | token num { \d+ } 0 401 400 | } 1 400 400 2 400 401 + class Calculations { 0 401 401 | method TOP ($/) { make $.made; } 0 401 401 | method calc-op:sym ($/) { make [+] $; } 0 401 401 | method calc-op:sym ($/) { make [-] $; } 0 401 400 | } 1 400 400 0 400 400 say Calculator.parse('2 + 3', actions => Calculations).made; 0 400 0 tmpok_q575y/lexilla/test/examples/erlang/0000775000175000017500000000000014773064066020250 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/erlang/SciTE.properties0000664000175000017500000000024314773064066023334 0ustar gusnangusnanlexer.*.erl=erlang keywords.*.erl=let keywords2.*.erl=atom_to_binary keywords3.*.erl=-define keywords4.*.erl=-module keywords5.*.erl=@todo keywords6.*.erl=@module tmpok_q575y/lexilla/test/examples/erlang/AllStyles.erl0000664000175000017500000000135614773064066022675 0ustar gusnangusnan% Enumerate all styles: 0..24 31 % comment = 1 % whitespace = 0 % 0 % variable = 2 A % number = 3 3 % keyword = 4 let % string = 5 "string" % operator = 6 * % atom = 7 atom % function_name = 8 function() % character = 9 $a % macro = 10 ?macro % record = 11 #record % preproc = 12 -define % node_name = 13 node@ % comment_function = 14 %% function % comment_module = 15 %%% module % comment_doc = 16 %% @todo % comment_doc_macro = 17 %% {@module} % atom_quoted = 18 (fails) 'fails' % macro_quoted = 19 ?'macro' % record_quoted = 20 #'record' % node_name_quoted = 21 'node@' % bifs = 22 atom_to_binary % modules = 23 io:x % modules_att = 24 -module(). % unknown = 31 (this is an internal state and should not be output) tmpok_q575y/lexilla/test/examples/erlang/AllStyles.erl.folded0000664000175000017500000000336114773064066024127 0ustar gusnangusnan 0 400 0 % Enumerate all styles: 0..24 31 0 400 0 0 400 0 % comment = 1 0 400 0 0 400 0 % whitespace = 0 0 400 0 % 0 0 400 0 0 400 0 % variable = 2 0 400 0 A 0 400 0 0 400 0 % number = 3 0 400 0 3 0 400 0 0 400 0 % keyword = 4 0 400 0 let 0 400 0 0 400 0 % string = 5 0 400 0 "string" 0 400 0 0 400 0 % operator = 6 0 400 0 * 0 400 0 0 400 0 % atom = 7 0 400 0 atom 0 400 0 0 400 0 % function_name = 8 0 400 0 function() 0 400 0 0 400 0 % character = 9 0 400 0 $a 0 400 0 0 400 0 % macro = 10 0 400 0 ?macro 0 400 0 0 400 0 % record = 11 0 400 0 #record 0 400 0 0 400 0 % preproc = 12 0 400 0 -define 0 400 0 0 400 0 % node_name = 13 0 400 0 node@ 0 400 0 0 400 0 % comment_function = 14 0 400 0 %% function 0 400 0 0 400 0 % comment_module = 15 0 400 0 %%% module 0 400 0 0 400 0 % comment_doc = 16 0 400 0 %% @todo 0 400 0 0 400 0 % comment_doc_macro = 17 0 400 0 %% {@module} 0 400 0 0 400 0 % atom_quoted = 18 (fails) 0 400 0 'fails' 0 400 0 0 400 0 % macro_quoted = 19 0 400 0 ?'macro' 0 400 0 0 400 0 % record_quoted = 20 0 400 0 #'record' 0 400 0 0 400 0 % node_name_quoted = 21 0 400 0 'node@' 0 400 0 0 400 0 % bifs = 22 0 400 0 atom_to_binary 0 400 0 0 400 0 % modules = 23 0 400 0 io:x 0 400 0 0 400 0 % modules_att = 24 0 400 0 -module(). 0 400 0 0 400 0 % unknown = 31 (this is an internal state and should not be output) 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/erlang/AllStyles.erl.styled0000664000175000017500000000210414773064066024170 0ustar gusnangusnan{1}% Enumerate all styles: 0..24 31{0} {1}% comment = 1{0} {1}% whitespace = 0{0} {1}% 0{0} {1}% variable = 2{0} {2}A{0} {1}% number = 3{0} {3}3{0} {1}% keyword = 4{0} {4}let{0} {1}% string = 5{0} {5}"string"{0} {1}% operator = 6{0} {6}*{0} {1}% atom = 7{0} {7}atom{0} {1}% function_name = 8{0} {8}function{6}(){0} {1}% character = 9{0} {9}$a{0} {1}% macro = 10{0} {10}?macro{0} {1}% record = 11{0} {11}#record{0} {1}% preproc = 12{0} {12}-define{0} {1}% node_name = 13{0} {13}node@{0} {1}% comment_function = 14{0} {14}%% function{0} {1}% comment_module = 15{0} {15}%%% module{0} {1}% comment_doc = 16{0} {14}%% {16}@todo{0} {1}% comment_doc_macro = 17{0} {14}%% {{17}@module{14}}{0} {1}% atom_quoted = 18 (fails){0} {18}'fails'{0} {1}% macro_quoted = 19{0} {19}?'macro'{0} {1}% record_quoted = 20{0} {20}#'record'{0} {1}% node_name_quoted = 21{0} {21}'node@'{0} {1}% bifs = 22{0} {22}atom_to_binary{0} {1}% modules = 23{0} {23}io:{7}x{0} {1}% modules_att = 24{0} {24}-module{6}().{0} {1}% unknown = 31 (this is an internal state and should not be output){0} tmpok_q575y/lexilla/test/examples/dart/0000775000175000017500000000000014773064066017732 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/dart/AllStyles.dart0000664000175000017500000001677614773064066022543 0ustar gusnangusnan// coding:utf-8 void main() { print('Hello, World!'); } var name = 'Voyager I'; var url = 'url' var year = 1977; var antennaDiameter = 3.7; var flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune']; var image = { 'tags': ['saturn'], url: '//path/to/saturn.jpg' }; if (year >= 2001) { print('21st century'); } else if (year >= 1901) { print('20th century'); } for (final object in flybyObjects) { print(object); } for (int month = 1; month <= 12; month++) { print(month); } while (year < 2016) { year += 1; } flybyObjects.where((name) => name.contains('turn')).forEach(print); // This is a normal, one-line comment. /// This is a documentation comment, used to document libraries, /// classes, and their members. Tools like IDEs and dartdoc treat /// doc comments specially. /* Comments like these are also supported. */ /** Comment block doc */ // Importing core libraries import 'dart:math'; // Importing libraries from external packages import 'package:test/test.dart'; // Importing files import 'path/to/my_other_file.dart'; class Spacecraft { String name; DateTime? launchDate; // Read-only non-final property int? get launchYear => launchDate?.year; // Constructor, with syntactic sugar for assignment to members. Spacecraft(this.name, this.launchDate) { // Initialization code goes here. } // Named constructor that forwards to the default one. Spacecraft.unlaunched(String name) : this(name, null); // Method. void describe() { print('Spacecraft: $name'); // Type promotion doesn't work on getters. var launchDate = this.launchDate; if (launchDate != null) { int years = DateTime.now().difference(launchDate).inDays ~/ 365; print('Launched: $launchYear ($years years ago)'); } else { print('Unlaunched'); } } } var voyager = Spacecraft('Voyager I', DateTime(1977, 9, 5)); voyager.describe(); var voyager3 = Spacecraft.unlaunched('Voyager III'); voyager3.describe(); enum PlanetType { terrestrial, gas, ice } /// Enum that enumerates the different planets in our solar system /// and some of their properties. enum Planet { mercury(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), venus(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), // ··· uranus(planetType: PlanetType.ice, moons: 27, hasRings: true), neptune(planetType: PlanetType.ice, moons: 14, hasRings: true); /// A constant generating constructor const Planet( {required this.planetType, required this.moons, required this.hasRings}); /// All instance variables are final final PlanetType planetType; final int moons; final bool hasRings; /// Enhanced enums support getters and other methods bool get isGiant => planetType == PlanetType.gas || planetType == PlanetType.ice; } final yourPlanet = Planet.earth; if (!yourPlanet.isGiant) { print('Your planet is not a "giant planet".'); } mixin Piloted { int astronauts = 1; void describeCrew() { print('Number of astronauts: $astronauts'); } } const oneSecond = Duration(seconds: 1); // ··· Future printWithDelay(String message) async { await Future.delayed(oneSecond); print(message); } Future printWithDelay(String message) { return Future.delayed(oneSecond).then((_) { print(message); }); } Future createDescriptions(Iterable objects) async { for (final object in objects) { try { var file = File('$object.txt'); if (await file.exists()) { var modified = await file.lastModified(); print( 'File for $object already exists. It was modified on $modified.'); continue; } await file.create(); await file.writeAsString('Start describing $object in this file.'); } on IOException catch (e) { print('Cannot create description for $object: $e'); } } } Stream report(Spacecraft craft, Iterable objects) async* { for (final object in objects) { await Future.delayed(oneSecond); yield '${craft.name} flies by $object'; } } Future describeFlybyObjects(List flybyObjects) async { try { for (final object in flybyObjects) { var description = await File('$object.txt').readAsString(); print(description); } } on IOException catch (e) { print('Could not describe object: $e'); } finally { flybyObjects.clear(); } } class Television { /// Use [turnOn] to turn the power on instead. @Deprecated('Use turnOn instead') void activate() { turnOn(); } /// Turns the TV's power on. void turnOn() {...} // ··· } String? name // Nullable type. Can be `null` or string. String name // Non-nullable type. Cannot be `null` but can be string. /// A domesticated South American camelid (Lama glama). /// /// Andean cultures have used llamas as meat and pack /// animals since pre-Hispanic times. /// /// Just like any other animal, llamas need to eat, /// so don't forget to [feed] them some [Food]. class Llama { String? name; /** Feeds your llama [food]. / / The typical llama eats one bale of hay per week. **/ void feed(Food food) { // ... } /// Exercises your llama with an [activity] for /// [timeLimit] minutes. void exercise(Activity activity, int timeLimit) { // ... } } import 'package:lib1/lib1.dart'; import 'package:lib2/lib2.dart' as lib2; // Import only foo. import 'package:lib1/lib1.dart' show foo; // Import all names EXCEPT foo. import 'package:lib2/lib2.dart' hide foo; print(#mysymbol); Symbol symbol = #myMethod; Symbol symbol2 = #<; Symbol symbol2 = #void; var x = 1; var hex = 0xDEADBEEF; var y = 1.1; var exponents = 1.42e5; var s1 = 'Single quotes work well for string literals.'; var s2 = "Double quotes work just as well."; var s3 = 'It\'s easy to escape the string delimiter.'; var s4 = "It's even easier to use the other delimiter."; var s = 'string interpolation'; assert('Dart has $s, which is very handy.' == 'Dart has string interpolation, ' 'which is very handy.'); assert('That deserves all caps. ' '${s.toUpperCase()} is very handy!' == 'That deserves all caps. ' 'STRING INTERPOLATION is very handy!'); var s1 = 'String ' 'concatenation' " works even over line breaks."; assert(s1 == 'String concatenation works even over ' 'line breaks.'); var s2 = 'The + operator ' + 'works, as well.'; assert(s2 == 'The + operator works, as well.'); var s1 = ''' You can create multi-line strings like this one. '''; var s2 = """This is also a multi-line string."""; var s = r'In a raw string, not even \n gets special treatment.'; var 2 = r"In a raw string, not even \n gets special treatment."; var s1 = r''' You can create multi-line strings like this one. '''; var s2 = r"""This is also a multi-line string."""; var record = ('first', a: 2, b: true, 'last'); var record = ('first', a: 2, b: true, 'last'); print(record.$1); // Prints 'first' print(record.a); // Prints 2 print(record.b); // Prints true print(record.$2); // Prints 'last' ({String name, int age}) userInfo(Map json) // ··· // Destructures using a record pattern with named fields: final (:name, :age) = userInfo(json); var list = [1, 2, 3]; var list = [ 'Car', 'Boat', 'Plane', ]; var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'}; var nobleGases = { 2: 'helium', 10: 'neon', 18: 'argon', }; var s = """This is also a ${foo( "$bar" )} multi-line string."""; var s1 = """multi line \n strings """; var s2 = """multi-line $x strings """; var s3 = """multi-line ${x} strings """; tmpok_q575y/lexilla/test/examples/dart/SciTE.properties0000664000175000017500000000253014773064066023017 0ustar gusnangusnanlexer.*.dart=dart fold=1 keywords.*.dart=abstract as assert async await base break case catch class const \ continue covariant default deferred do else enum export extends extension external \ factory false final finally for get hide if implements import in interface is late \ library mixin native new null of on operator part required rethrow return sealed \ set show static super switch sync this throw true try type typedef var when while \ with yield keywords2.*.dart=Function Never bool double dynamic int num void keywords3.*.dart=fBigInt Comparable Comparator Completer DateTime Deprecated \ Directory DoubleLinkedQueue Duration Enum Error Exception Expando File FileLock \ FileMode FileStat FileSystemEntity FileSystemEvent Future FutureOr HashMap HashSet \ IOException Invocation Iterable IterableBase IterableMixin Iterator LinkedHashMap \ LinkedHashSet LinkedList LinkedListEntry List ListBase ListMixin ListQueue Map \ MapBase MapEntry MapMixin MapView Match Null OSError Object Pattern Platform \ Point Process Queue Random RawSocket RawSocketEvent Record Rectangle RegExp \ RegExpMatch RuneIterator Runes ServerSocket Set SetBase SetMixin Sink Socket \ SocketException SplayTreeMap SplayTreeSet StackTrace Stopwatch Stream String \ StringBuffer StringSink Symbol SystemHash Timer Type Uri UriData WeakReference keywords4.*.dart=Spacecraft tmpok_q575y/lexilla/test/examples/dart/AllStyles.dart.styled0000664000175000017500000003325414773064066024034 0ustar gusnangusnan{1}// coding:utf-8 {0} {24}void{0} {14}main{16}(){0} {16}{{0} {14}print{16}({5}'Hello, World!'{16});{0} {16}}{0} {23}var{0} {14}name{0} {16}={0} {5}'Voyager I'{16};{0} {23}var{0} {14}url{0} {16}={0} {5}'url'{0} {23}var{0} {14}year{0} {16}={0} {20}1977{16};{0} {23}var{0} {14}antennaDiameter{0} {16}={0} {20}3.7{16};{0} {23}var{0} {14}flybyObjects{0} {16}={0} {16}[{5}'Jupiter'{16},{0} {5}'Saturn'{16},{0} {5}'Uranus'{16},{0} {5}'Neptune'{16}];{0} {23}var{0} {14}image{0} {16}={0} {16}{{0} {5}'tags'{16}:{0} {16}[{5}'saturn'{16}],{0} {21}url{16}:{0} {5}'//path/to/saturn.jpg'{0} {16}};{0} {23}if{0} {16}({14}year{0} {16}>={0} {20}2001{16}){0} {16}{{0} {14}print{16}({5}'21st century'{16});{0} {16}}{0} {23}else{0} {23}if{0} {16}({14}year{0} {16}>={0} {20}1901{16}){0} {16}{{0} {14}print{16}({5}'20th century'{16});{0} {16}}{0} {23}for{0} {16}({23}final{0} {14}object{0} {23}in{0} {14}flybyObjects{16}){0} {16}{{0} {14}print{16}({14}object{16});{0} {16}}{0} {23}for{0} {16}({24}int{0} {14}month{0} {16}={0} {20}1{16};{0} {14}month{0} {16}<={0} {20}12{16};{0} {14}month{16}++){0} {16}{{0} {14}print{16}({14}month{16});{0} {16}}{0} {23}while{0} {16}({14}year{0} {16}<{0} {20}2016{16}){0} {16}{{0} {14}year{0} {16}+={0} {20}1{16};{0} {16}}{0} {14}flybyObjects{16}.{14}where{16}(({14}name{16}){0} {16}=>{0} {14}name{16}.{14}contains{16}({5}'turn'{16})).{14}forEach{16}({14}print{16});{0} {1}// This is a normal, one-line comment. {0} {2}/// This is a documentation comment, used to document libraries, /// classes, and their members. Tools like IDEs and dartdoc treat /// doc comments specially. {0} {3}/* Comments like these are also supported. */{0} {4}/** Comment block doc */{0} {1}// Importing core libraries {23}import{0} {5}'dart:math'{16};{0} {1}// Importing libraries from external packages {23}import{0} {5}'package:test/test.dart'{16};{0} {1}// Importing files {23}import{0} {5}'path/to/my_other_file.dart'{16};{0} {23}class{0} {26}Spacecraft{0} {16}{{0} {25}String{0} {14}name{16};{0} {25}DateTime{16}?{0} {14}launchDate{16};{0} {1}// Read-only non-final property {0} {24}int{16}?{0} {23}get{0} {14}launchYear{0} {16}=>{0} {14}launchDate{16}?.{14}year{16};{0} {1}// Constructor, with syntactic sugar for assignment to members. {0} {26}Spacecraft{16}({23}this{16}.{14}name{16},{0} {23}this{16}.{14}launchDate{16}){0} {16}{{0} {1}// Initialization code goes here. {0} {16}}{0} {1}// Named constructor that forwards to the default one. {0} {26}Spacecraft{16}.{14}unlaunched{16}({25}String{0} {14}name{16}){0} {16}:{0} {23}this{16}({14}name{16},{0} {23}null{16});{0} {1}// Method. {0} {24}void{0} {14}describe{16}(){0} {16}{{0} {14}print{16}({5}'Spacecraft: {17}${15}name{5}'{16});{0} {1}// Type promotion doesn't work on getters. {0} {23}var{0} {14}launchDate{0} {16}={0} {23}this{16}.{14}launchDate{16};{0} {23}if{0} {16}({14}launchDate{0} {16}!={0} {23}null{16}){0} {16}{{0} {24}int{0} {14}years{0} {16}={0} {25}DateTime{16}.{14}now{16}().{14}difference{16}({14}launchDate{16}).{14}inDays{0} {16}~/{0} {20}365{16};{0} {14}print{16}({5}'Launched: {17}${15}launchYear{5} ({17}${15}years{5} years ago)'{16});{0} {16}}{0} {23}else{0} {16}{{0} {14}print{16}({5}'Unlaunched'{16});{0} {16}}{0} {16}}{0} {16}}{0} {23}var{0} {14}voyager{0} {16}={0} {26}Spacecraft{16}({5}'Voyager I'{16},{0} {25}DateTime{16}({20}1977{16},{0} {20}9{16},{0} {20}5{16}));{0} {14}voyager{16}.{14}describe{16}();{0} {23}var{0} {14}voyager3{0} {16}={0} {26}Spacecraft{16}.{14}unlaunched{16}({5}'Voyager III'{16});{0} {14}voyager3{16}.{14}describe{16}();{0} {23}enum{0} {14}PlanetType{0} {16}{{0} {14}terrestrial{16},{0} {14}gas{16},{0} {14}ice{0} {16}}{0} {2}/// Enum that enumerates the different planets in our solar system /// and some of their properties. {23}enum{0} {14}Planet{0} {16}{{0} {14}mercury{16}({21}planetType{16}:{0} {14}PlanetType{16}.{14}terrestrial{16},{0} {21}moons{16}:{0} {20}0{16},{0} {21}hasRings{16}:{0} {23}false{16}),{0} {14}venus{16}({21}planetType{16}:{0} {14}PlanetType{16}.{14}terrestrial{16},{0} {21}moons{16}:{0} {20}0{16},{0} {21}hasRings{16}:{0} {23}false{16}),{0} {1}// ··· {0} {14}uranus{16}({21}planetType{16}:{0} {14}PlanetType{16}.{14}ice{16},{0} {21}moons{16}:{0} {20}27{16},{0} {21}hasRings{16}:{0} {23}true{16}),{0} {14}neptune{16}({21}planetType{16}:{0} {14}PlanetType{16}.{14}ice{16},{0} {21}moons{16}:{0} {20}14{16},{0} {21}hasRings{16}:{0} {23}true{16});{0} {2}/// A constant generating constructor {0} {23}const{0} {14}Planet{16}({0} {16}{{23}required{0} {23}this{16}.{14}planetType{16},{0} {23}required{0} {23}this{16}.{14}moons{16},{0} {23}required{0} {23}this{16}.{14}hasRings{16}});{0} {2}/// All instance variables are final {0} {23}final{0} {14}PlanetType{0} {14}planetType{16};{0} {23}final{0} {24}int{0} {14}moons{16};{0} {23}final{0} {24}bool{0} {14}hasRings{16};{0} {2}/// Enhanced enums support getters and other methods {0} {24}bool{0} {23}get{0} {14}isGiant{0} {16}=>{0} {14}planetType{0} {16}=={0} {14}PlanetType{16}.{14}gas{0} {16}||{0} {14}planetType{0} {16}=={0} {14}PlanetType{16}.{14}ice{16};{0} {16}}{0} {23}final{0} {14}yourPlanet{0} {16}={0} {14}Planet{16}.{14}earth{16};{0} {23}if{0} {16}(!{14}yourPlanet{16}.{14}isGiant{16}){0} {16}{{0} {14}print{16}({5}'Your planet is not a "giant planet".'{16});{0} {16}}{0} {23}mixin{0} {14}Piloted{0} {16}{{0} {24}int{0} {14}astronauts{0} {16}={0} {20}1{16};{0} {24}void{0} {14}describeCrew{16}(){0} {16}{{0} {14}print{16}({5}'Number of astronauts: {17}${15}astronauts{5}'{16});{0} {16}}{0} {16}}{0} {23}const{0} {14}oneSecond{0} {16}={0} {25}Duration{16}({21}seconds{16}:{0} {20}1{16});{0} {1}// ··· {25}Future{16}<{24}void{16}>{0} {14}printWithDelay{16}({25}String{0} {14}message{16}){0} {23}async{0} {16}{{0} {23}await{0} {25}Future{16}.{14}delayed{16}({14}oneSecond{16});{0} {14}print{16}({14}message{16});{0} {16}}{0} {25}Future{16}<{24}void{16}>{0} {14}printWithDelay{16}({25}String{0} {14}message{16}){0} {16}{{0} {23}return{0} {25}Future{16}.{14}delayed{16}({14}oneSecond{16}).{14}then{16}(({14}_{16}){0} {16}{{0} {14}print{16}({14}message{16});{0} {16}});{0} {16}}{0} {25}Future{16}<{24}void{16}>{0} {14}createDescriptions{16}({25}Iterable{16}<{25}String{16}>{0} {14}objects{16}){0} {23}async{0} {16}{{0} {23}for{0} {16}({23}final{0} {14}object{0} {23}in{0} {14}objects{16}){0} {16}{{0} {23}try{0} {16}{{0} {23}var{0} {14}file{0} {16}={0} {25}File{16}({5}'{17}${15}object{5}.txt'{16});{0} {23}if{0} {16}({23}await{0} {14}file{16}.{14}exists{16}()){0} {16}{{0} {23}var{0} {14}modified{0} {16}={0} {23}await{0} {14}file{16}.{14}lastModified{16}();{0} {14}print{16}({0} {5}'File for {17}${15}object{5} already exists. It was modified on {17}${15}modified{5}.'{16});{0} {23}continue{16};{0} {16}}{0} {23}await{0} {14}file{16}.{14}create{16}();{0} {23}await{0} {14}file{16}.{14}writeAsString{16}({5}'Start describing {17}${15}object{5} in this file.'{16});{0} {16}}{0} {23}on{0} {25}IOException{0} {23}catch{0} {16}({14}e{16}){0} {16}{{0} {14}print{16}({5}'Cannot create description for {17}${15}object{5}: {17}${15}e{5}'{16});{0} {16}}{0} {16}}{0} {16}}{0} {25}Stream{16}<{25}String{16}>{0} {14}report{16}({26}Spacecraft{0} {14}craft{16},{0} {25}Iterable{16}<{25}String{16}>{0} {14}objects{16}){0} {23}async{16}*{0} {16}{{0} {23}for{0} {16}({23}final{0} {14}object{0} {23}in{0} {14}objects{16}){0} {16}{{0} {23}await{0} {25}Future{16}.{14}delayed{16}({14}oneSecond{16});{0} {23}yield{0} {5}'{17}${{14}craft{16}.{14}name{17}}{5} flies by {17}${15}object{5}'{16};{0} {16}}{0} {16}}{0} {25}Future{16}<{24}void{16}>{0} {14}describeFlybyObjects{16}({25}List{16}<{25}String{16}>{0} {14}flybyObjects{16}){0} {23}async{0} {16}{{0} {23}try{0} {16}{{0} {23}for{0} {16}({23}final{0} {14}object{0} {23}in{0} {14}flybyObjects{16}){0} {16}{{0} {23}var{0} {14}description{0} {16}={0} {23}await{0} {25}File{16}({5}'{17}${15}object{5}.txt'{16}).{14}readAsString{16}();{0} {14}print{16}({14}description{16});{0} {16}}{0} {16}}{0} {23}on{0} {25}IOException{0} {23}catch{0} {16}({14}e{16}){0} {16}{{0} {14}print{16}({5}'Could not describe object: {17}${15}e{5}'{16});{0} {16}}{0} {23}finally{0} {16}{{0} {14}flybyObjects{16}.{14}clear{16}();{0} {16}}{0} {16}}{0} {23}class{0} {14}Television{0} {16}{{0} {2}/// Use [turnOn] to turn the power on instead. {0} {22}@Deprecated{16}({5}'Use turnOn instead'{16}){0} {24}void{0} {14}activate{16}(){0} {16}{{0} {14}turnOn{16}();{0} {16}}{0} {2}/// Turns the TV's power on. {0} {24}void{0} {14}turnOn{16}(){0} {16}{...}{0} {1}// ··· {16}}{0} {25}String{16}?{0} {14}name{0} {1}// Nullable type. Can be `null` or string. {0} {25}String{0} {14}name{0} {1}// Non-nullable type. Cannot be `null` but can be string. {0} {2}/// A domesticated South American camelid (Lama glama). /// /// Andean cultures have used llamas as meat and pack /// animals since pre-Hispanic times. /// /// Just like any other animal, llamas need to eat, /// so don't forget to [feed] them some [Food]. {23}class{0} {14}Llama{0} {16}{{0} {25}String{16}?{0} {14}name{16};{0} {4}/** Feeds your llama [food]. / / The typical llama eats one bale of hay per week. **/{0} {24}void{0} {14}feed{16}({14}Food{0} {14}food{16}){0} {16}{{0} {1}// ... {0} {16}}{0} {2}/// Exercises your llama with an [activity] for {0} {2}/// [timeLimit] minutes. {0} {24}void{0} {14}exercise{16}({14}Activity{0} {14}activity{16},{0} {24}int{0} {14}timeLimit{16}){0} {16}{{0} {1}// ... {0} {16}}{0} {16}}{0} {23}import{0} {5}'package:lib1/lib1.dart'{16};{0} {23}import{0} {5}'package:lib2/lib2.dart'{0} {23}as{0} {14}lib2{16};{0} {1}// Import only foo. {23}import{0} {5}'package:lib1/lib1.dart'{0} {23}show{0} {14}foo{16};{0} {1}// Import all names EXCEPT foo. {23}import{0} {5}'package:lib2/lib2.dart'{0} {23}hide{0} {14}foo{16};{0} {14}print{16}({18}#mysymbol{16});{0} {25}Symbol{0} {14}symbol{0} {16}={0} {18}#myMethod{16};{0} {25}Symbol{0} {14}symbol2{0} {16}={0} {19}#<{16};{0} {25}Symbol{0} {14}symbol2{0} {16}={0} {18}#void{16};{0} {23}var{0} {14}x{0} {16}={0} {20}1{16};{0} {23}var{0} {14}hex{0} {16}={0} {20}0xDEADBEEF{16};{0} {23}var{0} {14}y{0} {16}={0} {20}1.1{16};{0} {23}var{0} {14}exponents{0} {16}={0} {20}1.42e5{16};{0} {23}var{0} {14}s1{0} {16}={0} {5}'Single quotes work well for string literals.'{16};{0} {23}var{0} {14}s2{0} {16}={0} {6}"Double quotes work just as well."{16};{0} {23}var{0} {14}s3{0} {16}={0} {5}'It{13}\'{5}s easy to escape the string delimiter.'{16};{0} {23}var{0} {14}s4{0} {16}={0} {6}"It's even easier to use the other delimiter."{16};{0} {23}var{0} {14}s{0} {16}={0} {5}'string interpolation'{16};{0} {23}assert{16}({5}'Dart has {17}${15}s{5}, which is very handy.'{0} {16}=={0} {5}'Dart has string interpolation, '{0} {5}'which is very handy.'{16});{0} {23}assert{16}({5}'That deserves all caps. '{0} {5}'{17}${{14}s{16}.{14}toUpperCase{16}(){17}}{5} is very handy!'{0} {16}=={0} {5}'That deserves all caps. '{0} {5}'STRING INTERPOLATION is very handy!'{16});{0} {23}var{0} {14}s1{0} {16}={0} {5}'String '{0} {5}'concatenation'{0} {6}" works even over line breaks."{16};{0} {23}assert{16}({14}s1{0} {16}=={0} {5}'String concatenation works even over '{0} {5}'line breaks.'{16});{0} {23}var{0} {14}s2{0} {16}={0} {5}'The + operator '{0} {16}+{0} {5}'works, as well.'{16};{0} {23}assert{16}({14}s2{0} {16}=={0} {5}'The + operator works, as well.'{16});{0} {23}var{0} {14}s1{0} {16}={0} {7}''' You can create multi-line strings like this one. '''{16};{0} {23}var{0} {14}s2{0} {16}={0} {8}"""This is also a multi-line string."""{16};{0} {23}var{0} {14}s{0} {16}={0} {9}r'In a raw string, not even \n gets special treatment.'{16};{0} {23}var{0} {20}2{0} {16}={0} {10}r"In a raw string, not even \n gets special treatment."{16};{0} {23}var{0} {14}s1{0} {16}={0} {11}r''' You can create multi-line strings like this one. '''{16};{0} {23}var{0} {14}s2{0} {16}={0} {12}r"""This is also a multi-line string."""{16};{0} {23}var{0} {14}record{0} {16}={0} {16}({5}'first'{16},{0} {21}a{16}:{0} {20}2{16},{0} {21}b{16}:{0} {23}true{16},{0} {5}'last'{16});{0} {23}var{0} {14}record{0} {16}={0} {16}({5}'first'{16},{0} {21}a{16}:{0} {20}2{16},{0} {21}b{16}:{0} {23}true{16},{0} {5}'last'{16});{0} {14}print{16}({14}record{16}.{14}$1{16});{0} {1}// Prints 'first' {14}print{16}({14}record{16}.{14}a{16});{0} {1}// Prints 2 {14}print{16}({14}record{16}.{14}b{16});{0} {1}// Prints true {14}print{16}({14}record{16}.{14}$2{16});{0} {1}// Prints 'last' {0} {16}({{25}String{0} {14}name{16},{0} {24}int{0} {14}age{16}}){0} {14}userInfo{16}({25}Map{16}<{25}String{16},{0} {24}dynamic{16}>{0} {14}json{16}){0} {1}// ··· // Destructures using a record pattern with named fields: {23}final{0} {16}(:{14}name{16},{0} {16}:{14}age{16}){0} {16}={0} {14}userInfo{16}({14}json{16});{0} {23}var{0} {14}list{0} {16}={0} {16}[{20}1{16},{0} {20}2{16},{0} {20}3{16}];{0} {23}var{0} {14}list{0} {16}={0} {16}[{0} {5}'Car'{16},{0} {5}'Boat'{16},{0} {5}'Plane'{16},{0} {16}];{0} {23}var{0} {14}halogens{0} {16}={0} {16}{{5}'fluorine'{16},{0} {5}'chlorine'{16},{0} {5}'bromine'{16},{0} {5}'iodine'{16},{0} {5}'astatine'{16}};{0} {23}var{0} {14}nobleGases{0} {16}={0} {16}{{0} {20}2{16}:{0} {5}'helium'{16},{0} {20}10{16}:{0} {5}'neon'{16},{0} {20}18{16}:{0} {5}'argon'{16},{0} {16}};{0} {23}var{0} {14}s{0} {16}={0} {8}"""This is also a {17}${{14}foo{16}({0} {6}"{17}${15}bar{6}"{0} {16}){17}}{8} multi-line string."""{16};{0} {23}var{0} {14}s1{0} {16}={0} {8}"""multi line {13}\n{8} strings """{16};{0} {23}var{0} {14}s2{0} {16}={0} {8}"""multi-line {17}${15}x{8} strings """{16};{0} {23}var{0} {14}s3{0} {16}={0} {8}"""multi-line {17}${{14}x{17}}{8} strings """{16};{0} tmpok_q575y/lexilla/test/examples/dart/AllStyles.dart.folded0000664000175000017500000002740114773064066023762 0ustar gusnangusnan 0 400 400 // coding:utf-8 0 400 400 2 400 401 + void main() { 0 401 401 | print('Hello, World!'); 0 401 400 | } 0 400 400 0 400 400 var name = 'Voyager I'; 0 400 400 var url = 'url' 0 400 400 var year = 1977; 0 400 400 var antennaDiameter = 3.7; 0 400 400 var flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune']; 2 400 401 + var image = { 0 401 401 | 'tags': ['saturn'], 0 401 401 | url: '//path/to/saturn.jpg' 0 401 400 | }; 0 400 400 0 400 400 2 400 401 + if (year >= 2001) { 0 401 401 | print('21st century'); 0 401 401 | } else if (year >= 1901) { 0 401 401 | print('20th century'); 0 401 400 | } 0 400 400 2 400 401 + for (final object in flybyObjects) { 0 401 401 | print(object); 0 401 400 | } 0 400 400 2 400 401 + for (int month = 1; month <= 12; month++) { 0 401 401 | print(month); 0 401 400 | } 0 400 400 2 400 401 + while (year < 2016) { 0 401 401 | year += 1; 0 401 400 | } 0 400 400 0 400 400 flybyObjects.where((name) => name.contains('turn')).forEach(print); 0 400 400 0 400 400 // This is a normal, one-line comment. 0 400 400 2 400 401 + /// This is a documentation comment, used to document libraries, 0 401 401 | /// classes, and their members. Tools like IDEs and dartdoc treat 0 401 400 | /// doc comments specially. 0 400 400 0 400 400 /* Comments like these are also supported. */ 0 400 400 2 400 401 + /** Comment 0 401 400 | block doc */ 0 400 400 0 400 400 // Importing core libraries 0 400 400 import 'dart:math'; 0 400 400 0 400 400 // Importing libraries from external packages 0 400 400 import 'package:test/test.dart'; 0 400 400 0 400 400 // Importing files 0 400 400 import 'path/to/my_other_file.dart'; 0 400 400 2 400 401 + class Spacecraft { 0 401 401 | String name; 0 401 401 | DateTime? launchDate; 0 401 401 | 0 401 401 | // Read-only non-final property 0 401 401 | int? get launchYear => launchDate?.year; 0 401 401 | 0 401 401 | // Constructor, with syntactic sugar for assignment to members. 2 401 402 + Spacecraft(this.name, this.launchDate) { 0 402 402 | // Initialization code goes here. 0 402 401 | } 0 401 401 | 0 401 401 | // Named constructor that forwards to the default one. 0 401 401 | Spacecraft.unlaunched(String name) : this(name, null); 0 401 401 | 0 401 401 | // Method. 2 401 402 + void describe() { 0 402 402 | print('Spacecraft: $name'); 0 402 402 | // Type promotion doesn't work on getters. 0 402 402 | var launchDate = this.launchDate; 2 402 403 + if (launchDate != null) { 0 403 403 | int years = DateTime.now().difference(launchDate).inDays ~/ 365; 0 403 403 | print('Launched: $launchYear ($years years ago)'); 0 403 403 | } else { 0 403 403 | print('Unlaunched'); 0 403 402 | } 0 402 401 | } 0 401 400 | } 0 400 400 0 400 400 var voyager = Spacecraft('Voyager I', DateTime(1977, 9, 5)); 0 400 400 voyager.describe(); 0 400 400 0 400 400 var voyager3 = Spacecraft.unlaunched('Voyager III'); 0 400 400 voyager3.describe(); 0 400 400 0 400 400 enum PlanetType { terrestrial, gas, ice } 0 400 400 2 400 401 + /// Enum that enumerates the different planets in our solar system 0 401 400 | /// and some of their properties. 2 400 401 + enum Planet { 0 401 401 | mercury(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), 0 401 401 | venus(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), 0 401 401 | // ··· 0 401 401 | uranus(planetType: PlanetType.ice, moons: 27, hasRings: true), 0 401 401 | neptune(planetType: PlanetType.ice, moons: 14, hasRings: true); 0 401 401 | 0 401 401 | /// A constant generating constructor 2 401 402 + const Planet( 0 402 401 | {required this.planetType, required this.moons, required this.hasRings}); 0 401 401 | 0 401 401 | /// All instance variables are final 0 401 401 | final PlanetType planetType; 0 401 401 | final int moons; 0 401 401 | final bool hasRings; 0 401 401 | 0 401 401 | /// Enhanced enums support getters and other methods 0 401 401 | bool get isGiant => 0 401 401 | planetType == PlanetType.gas || planetType == PlanetType.ice; 0 401 400 | } 0 400 400 0 400 400 final yourPlanet = Planet.earth; 0 400 400 2 400 401 + if (!yourPlanet.isGiant) { 0 401 401 | print('Your planet is not a "giant planet".'); 0 401 400 | } 0 400 400 2 400 401 + mixin Piloted { 0 401 401 | int astronauts = 1; 0 401 401 | 2 401 402 + void describeCrew() { 0 402 402 | print('Number of astronauts: $astronauts'); 0 402 401 | } 0 401 400 | } 0 400 400 0 400 400 const oneSecond = Duration(seconds: 1); 0 400 400 // ··· 2 400 401 + Future printWithDelay(String message) async { 0 401 401 | await Future.delayed(oneSecond); 0 401 401 | print(message); 0 401 400 | } 0 400 400 0 400 400 2 400 401 + Future printWithDelay(String message) { 2 401 403 + return Future.delayed(oneSecond).then((_) { 0 403 403 | print(message); 0 403 401 | }); 0 401 400 | } 0 400 400 2 400 401 + Future createDescriptions(Iterable objects) async { 2 401 402 + for (final object in objects) { 2 402 403 + try { 0 403 403 | var file = File('$object.txt'); 2 403 404 + if (await file.exists()) { 0 404 404 | var modified = await file.lastModified(); 2 404 405 + print( 0 405 404 | 'File for $object already exists. It was modified on $modified.'); 0 404 404 | continue; 0 404 403 | } 0 403 403 | await file.create(); 0 403 403 | await file.writeAsString('Start describing $object in this file.'); 0 403 403 | } on IOException catch (e) { 0 403 403 | print('Cannot create description for $object: $e'); 0 403 402 | } 0 402 401 | } 0 401 400 | } 0 400 400 2 400 401 + Stream report(Spacecraft craft, Iterable objects) async* { 2 401 402 + for (final object in objects) { 0 402 402 | await Future.delayed(oneSecond); 0 402 402 | yield '${craft.name} flies by $object'; 0 402 401 | } 0 401 400 | } 0 400 400 2 400 401 + Future describeFlybyObjects(List flybyObjects) async { 2 401 402 + try { 2 402 403 + for (final object in flybyObjects) { 0 403 403 | var description = await File('$object.txt').readAsString(); 0 403 403 | print(description); 0 403 402 | } 0 402 402 | } on IOException catch (e) { 0 402 402 | print('Could not describe object: $e'); 0 402 402 | } finally { 0 402 402 | flybyObjects.clear(); 0 402 401 | } 0 401 400 | } 0 400 400 2 400 401 + class Television { 0 401 401 | /// Use [turnOn] to turn the power on instead. 0 401 401 | @Deprecated('Use turnOn instead') 2 401 402 + void activate() { 0 402 402 | turnOn(); 0 402 401 | } 0 401 401 | 0 401 401 | /// Turns the TV's power on. 0 401 401 | void turnOn() {...} 0 401 401 | // ··· 0 401 400 | } 0 400 400 0 400 400 String? name // Nullable type. Can be `null` or string. 0 400 400 0 400 400 String name // Non-nullable type. Cannot be `null` but can be string. 0 400 400 0 400 400 2 400 401 + /// A domesticated South American camelid (Lama glama). 0 401 401 | /// 0 401 401 | /// Andean cultures have used llamas as meat and pack 0 401 401 | /// animals since pre-Hispanic times. 0 401 401 | /// 0 401 401 | /// Just like any other animal, llamas need to eat, 0 401 400 | /// so don't forget to [feed] them some [Food]. 2 400 401 + class Llama { 0 401 401 | String? name; 0 401 401 | 2 401 402 + /** Feeds your llama [food]. 0 402 402 | / 0 402 401 | / The typical llama eats one bale of hay per week. **/ 2 401 402 + void feed(Food food) { 0 402 402 | // ... 0 402 401 | } 0 401 401 | 2 401 402 + /// Exercises your llama with an [activity] for 0 402 401 | /// [timeLimit] minutes. 2 401 402 + void exercise(Activity activity, int timeLimit) { 0 402 402 | // ... 0 402 401 | } 0 401 400 | } 0 400 400 2 400 401 + import 'package:lib1/lib1.dart'; 0 401 400 | import 'package:lib2/lib2.dart' as lib2; 0 400 400 // Import only foo. 0 400 400 import 'package:lib1/lib1.dart' show foo; 0 400 400 // Import all names EXCEPT foo. 0 400 400 import 'package:lib2/lib2.dart' hide foo; 0 400 400 0 400 400 print(#mysymbol); 0 400 400 Symbol symbol = #myMethod; 0 400 400 Symbol symbol2 = #<; 0 400 400 Symbol symbol2 = #void; 0 400 400 0 400 400 var x = 1; 0 400 400 var hex = 0xDEADBEEF; 0 400 400 var y = 1.1; 0 400 400 var exponents = 1.42e5; 0 400 400 0 400 400 var s1 = 'Single quotes work well for string literals.'; 0 400 400 var s2 = "Double quotes work just as well."; 0 400 400 var s3 = 'It\'s easy to escape the string delimiter.'; 0 400 400 var s4 = "It's even easier to use the other delimiter."; 0 400 400 0 400 400 var s = 'string interpolation'; 0 400 400 2 400 401 + assert('Dart has $s, which is very handy.' == 0 401 401 | 'Dart has string interpolation, ' 0 401 400 | 'which is very handy.'); 2 400 401 + assert('That deserves all caps. ' 0 401 401 | '${s.toUpperCase()} is very handy!' == 0 401 401 | 'That deserves all caps. ' 0 401 400 | 'STRING INTERPOLATION is very handy!'); 0 400 400 0 400 400 var s1 = 'String ' 0 400 400 'concatenation' 0 400 400 " works even over line breaks."; 2 400 401 + assert(s1 == 0 401 401 | 'String concatenation works even over ' 0 401 400 | 'line breaks.'); 0 400 400 0 400 400 var s2 = 'The + operator ' + 'works, as well.'; 0 400 400 assert(s2 == 'The + operator works, as well.'); 0 400 400 2 400 401 + var s1 = ''' 0 401 401 | You can create 0 401 401 | multi-line strings like this one. 0 401 400 | '''; 0 400 400 2 400 401 + var s2 = """This is also a 0 401 400 | multi-line string."""; 0 400 400 0 400 400 var s = r'In a raw string, not even \n gets special treatment.'; 0 400 400 var 2 = r"In a raw string, not even \n gets special treatment."; 0 400 400 2 400 401 + var s1 = r''' 0 401 401 | You can create 0 401 401 | multi-line strings like this one. 0 401 400 | '''; 0 400 400 2 400 401 + var s2 = r"""This is also a 0 401 400 | multi-line string."""; 0 400 400 0 400 400 var record = ('first', a: 2, b: true, 'last'); 0 400 400 0 400 400 var record = ('first', a: 2, b: true, 'last'); 0 400 400 0 400 400 print(record.$1); // Prints 'first' 0 400 400 print(record.a); // Prints 2 0 400 400 print(record.b); // Prints true 0 400 400 print(record.$2); // Prints 'last' 0 400 400 0 400 400 ({String name, int age}) userInfo(Map json) 2 400 401 + // ··· 0 401 400 | // Destructures using a record pattern with named fields: 0 400 400 final (:name, :age) = userInfo(json); 0 400 400 0 400 400 var list = [1, 2, 3]; 2 400 401 + var list = [ 0 401 401 | 'Car', 0 401 401 | 'Boat', 0 401 401 | 'Plane', 0 401 400 | ]; 0 400 400 var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'}; 0 400 400 2 400 401 + var nobleGases = { 0 401 401 | 2: 'helium', 0 401 401 | 10: 'neon', 0 401 401 | 18: 'argon', 0 401 400 | }; 0 400 400 2 400 401 + var s = """This is also a 2 401 403 + ${foo( 0 403 403 | "$bar" 0 403 401 | )} 0 401 400 | multi-line string."""; 0 400 400 2 400 401 + var s1 = """multi 0 401 401 | line 0 401 401 | \n 0 401 401 | strings 0 401 400 | """; 0 400 400 2 400 401 + var s2 = """multi-line 0 401 401 | $x 0 401 401 | strings 0 401 400 | """; 0 400 400 2 400 401 + var s3 = """multi-line 0 401 401 | ${x} 0 401 401 | strings 0 401 400 | """; 0 400 0 tmpok_q575y/lexilla/test/examples/mssql/0000775000175000017500000000000014773064066020137 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/mssql/Various.tsql0000664000175000017500000000467614773064066022511 0ustar gusnangusnan/* This file contains snippets of Transact-SQL that exercise various aspects of the language. */ /** /* AllStyles.tsql /* /****** Object: Database [AllStyles] Script Date: 06/16/2022 10:56:35 PM ******/ */ */ */ IF (1 = FULLTEXTSERVICEPROPERTY('IsFullTextInstalled')) BEGIN EXEC sp_fulltext_database @action = 'enable'; END USE AllStyles; GO SELECT * FROM Production.Product ORDER BY Name ASC; -- Alternate way. USE AllStyles; GO SELECT p.* FROM Production.Product AS p ORDER BY Name ASC; GO SELECT "COLUMN" FROM "TABLE" SELECT "COLUMN" int FROM "TABLE" SELECT schema_name (tab.schema_id) AS schema_name -- retrieve the name, too ,tab.name FROM sys.tables AS tab; SELECT DISTINCT Name FROM Production.Product AS p WHERE EXISTS (SELECT * FROM Production.ProductModel AS pm WHERE p.ProductModelID = pm.ProductModelID AND pm.Name LIKE 'Long-Sleeve Logo Jersey%'); SELECT DISTINCT p.LastName, p.FirstName FROM Person.Person AS p JOIN HumanResources.Employee AS e ON e.BusinessEntityID = p.BusinessEntityID WHERE 5000.00 IN (SELECT Bonus FROM Sales.SalesPerson AS sp WHERE e.BusinessEntityID = sp.BusinessEntityID); CREATE PROCEDURE findjobs @nm sysname = NULL AS IF @nm IS NULL BEGIN PRINT 'You must give a user name' RETURN END ELSE BEGIN SELECT o.name, o.id, o.uid FROM sysobjects o INNER JOIN master.syslogins l ON o.uid = l.sid WHERE l.name = @nm END; CREATE TABLE TestTable (cola INT, colb CHAR(3)); -- Declare the variable to be used. DECLARE @MyCounter INT; -- Initialize the variable. SET @MyCounter = 0; WHILE (@MyCounter < 26) BEGIN; -- Insert a row into the table. INSERT INTO TestTable VALUES -- Use the variable to provide the integer value -- for cola. Also use it to generate a unique letter -- for each row. Use the ASCII function to get the -- integer value of 'a'. Add @MyCounter. Use CHAR to -- convert the sum back to the character @MyCounter -- characters after 'a'. (@MyCounter, CHAR( ( @MyCounter + ASCII('a') ) ) ); -- Increment the variable to count this iteration -- of the loop. SET @MyCounter = @MyCounter + 1; END; IF @@ERROR = 547 BEGIN PRINT N'A check constraint violation occurred.'; END GO USE [AllStyles].[dbo].[test] GO SELECT ProductID FROM Production.Product INTERSECT SELECT ProductID FROM Production.WorkOrder ; tmpok_q575y/lexilla/test/examples/mssql/AllStyles.tsql.folded0000664000175000017500000000231314773064066024213 0ustar gusnangusnan 0 400 0 -- Enumerate all styles: 0 to 16 1 400 0 0 400 0 /* block comment = 1*/ 1 400 0 0 400 0 -- whitespace = 0 0 400 0 -- spaces 1 400 0 0 400 0 -- line comment = 2 1 400 0 0 400 0 -- number = 3 0 400 0 376 1 400 0 0 400 0 -- string = 4 0 400 0 'a string' 1 400 0 0 400 0 -- operator = 5 0 400 0 () 0 400 0 INTERSECT 1 400 0 0 400 0 -- identifier = 6 0 400 0 ProductID; 1 400 0 0 400 0 -- variable = 7 0 400 0 @Variable; 1 400 0 0 400 0 -- column name = 8 0 400 0 "COLUMN"; 1 400 0 0 400 0 -- statement = 9 0 400 0 PRINT 1 400 0 0 400 0 -- datatype = 10 0 400 0 int 1 400 0 0 400 0 -- systable = 11 0 400 0 sysobjects 1 400 0 0 400 0 -- global variable = 12 0 400 0 @@ERROR 1 400 0 0 400 0 -- function = 13 0 400 0 object_id 1 400 0 0 400 0 -- stored procedure = 14 0 400 0 sp_fulltext_database 1 400 0 0 400 0 -- default (preferencing data type) = 15 0 400 0 x -- 1 400 0 0 400 0 -- column name 2 = 16 0 400 0 [COLUMN]; 1 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/mssql/Issue87.tsql0000664000175000017500000000020714773064066022312 0ustar gusnangusnan/** /* GitHub Issue 87 /* /****** Object: Table [dbo].[Issue87] Script Date: 04/06/2022 8:07:57 PM ******/ */ */ */ tmpok_q575y/lexilla/test/examples/mssql/SciTE.properties0000664000175000017500000000103614773064066023224 0ustar gusnangusnanlexer.*.tsql=mssql fold=1 fold.comment=1 # statement keywords.*.tsql=and as begin by create declare distinct drop else end exists from go if in insert into is inner \ join like not null on order print procedure return select set table use values where while # data type keywords2.*.tsql=char int # System table keywords3.*.tsql=sysobjects # global variables keywords4.*.tsql=error # functions keywords5.*.tsql=ascii char object_id # System stored procedures keywords6.*.tsql=sp_fulltext_database # operators keywords7.*.tsql=intersect tmpok_q575y/lexilla/test/examples/mssql/AllStyles.tsql.styled0000664000175000017500000000137714773064066024273 0ustar gusnangusnan{2}-- Enumerate all styles: 0 to 16{0} {1}/* block comment = 1*/{0} {2}-- whitespace = 0{0} {2}-- spaces{0} {2}-- line comment = 2{0} {2}-- number = 3{0} {3}376{0} {2}-- string = 4{0} {4}'a string'{0} {2}-- operator = 5{0} {5}(){0} {5}INTERSECT{0} {2}-- identifier = 6{0} {6}ProductID{5};{0} {2}-- variable = 7{0} {7}@Variable{5};{0} {2}-- column name = 8{0} {8}"COLUMN"{5};{0} {2}-- statement = 9{0} {9}PRINT{0} {2}-- datatype = 10{0} {10}int{0} {2}-- systable = 11{0} {11}sysobjects{0} {2}-- global variable = 12{0} {12}@@ERROR{0} {2}-- function = 13{0} {13}object_id{0} {2}-- stored procedure = 14{0} {14}sp_fulltext_database{0} {2}-- default (preferencing data type) = 15{0} {6}x{15} {2}--{0} {2}-- column name 2 = 16{0} {16}[COLUMN]{5};{0} tmpok_q575y/lexilla/test/examples/mssql/Issue90.tsql0000664000175000017500000000006014773064066022301 0ustar gusnangusnanCREATE TABLE TestTable ( col CHAR(3) ); tmpok_q575y/lexilla/test/examples/mssql/AllStyles.tsql0000664000175000017500000000103214773064066022754 0ustar gusnangusnan-- Enumerate all styles: 0 to 16 /* block comment = 1*/ -- whitespace = 0 -- spaces -- line comment = 2 -- number = 3 376 -- string = 4 'a string' -- operator = 5 () INTERSECT -- identifier = 6 ProductID; -- variable = 7 @Variable; -- column name = 8 "COLUMN"; -- statement = 9 PRINT -- datatype = 10 int -- systable = 11 sysobjects -- global variable = 12 @@ERROR -- function = 13 object_id -- stored procedure = 14 sp_fulltext_database -- default (preferencing data type) = 15 x -- -- column name 2 = 16 [COLUMN]; tmpok_q575y/lexilla/test/examples/mssql/Various.tsql.folded0000664000175000017500000000742314773064066023736 0ustar gusnangusnan 0 400 0 /* This file contains snippets of Transact-SQL that exercise various aspects of the language. */ 2 400 0 + /** 0 401 0 | /* 0 401 0 | AllStyles.tsql 0 401 0 | /* 0 401 0 | /****** Object: Database [AllStyles] Script Date: 06/16/2022 10:56:35 PM ******/ 0 401 0 | */ 0 401 0 | */ 0 401 0 | */ 0 400 0 IF (1 = FULLTEXTSERVICEPROPERTY('IsFullTextInstalled')) 2 400 0 + BEGIN 0 401 0 | EXEC sp_fulltext_database @action = 'enable'; 0 401 0 | END 0 400 0 USE AllStyles; 0 400 0 GO 0 400 0 SELECT * 0 400 0 FROM Production.Product 0 400 0 ORDER BY Name ASC; 0 400 0 -- Alternate way. 0 400 0 USE AllStyles; 0 400 0 GO 0 400 0 SELECT p.* 0 400 0 FROM Production.Product AS p 0 400 0 ORDER BY Name ASC; 0 400 0 GO 1 400 0 0 400 0 SELECT "COLUMN" FROM "TABLE" 0 400 0 SELECT "COLUMN" int FROM "TABLE" 1 400 0 0 400 0 SELECT schema_name 0 400 0 (tab.schema_id) AS schema_name 0 400 0 -- retrieve the name, too 0 400 0 ,tab.name 0 400 0 FROM sys.tables AS tab; 1 400 0 0 400 0 SELECT DISTINCT Name 0 400 0 FROM Production.Product AS p 0 400 0 WHERE EXISTS 0 400 0 (SELECT * 0 400 0 FROM Production.ProductModel AS pm 0 400 0 WHERE p.ProductModelID = pm.ProductModelID 0 400 0 AND pm.Name LIKE 'Long-Sleeve Logo Jersey%'); 1 400 0 0 400 0 SELECT DISTINCT p.LastName, p.FirstName 0 400 0 FROM Person.Person AS p 0 400 0 JOIN HumanResources.Employee AS e 0 400 0 ON e.BusinessEntityID = p.BusinessEntityID WHERE 5000.00 IN 0 400 0 (SELECT Bonus 0 400 0 FROM Sales.SalesPerson AS sp 0 400 0 WHERE e.BusinessEntityID = sp.BusinessEntityID); 1 400 0 0 400 0 CREATE PROCEDURE findjobs @nm sysname = NULL 0 400 0 AS 0 400 0 IF @nm IS NULL 2 400 0 + BEGIN 0 401 0 | PRINT 'You must give a user name' 0 401 0 | RETURN 0 401 0 | END 0 400 0 ELSE 2 400 0 + BEGIN 0 401 0 | SELECT o.name, o.id, o.uid 0 401 0 | FROM sysobjects o INNER JOIN master.syslogins l 0 401 0 | ON o.uid = l.sid 0 401 0 | WHERE l.name = @nm 0 401 0 | END; 1 400 0 0 400 0 CREATE TABLE TestTable (cola INT, colb CHAR(3)); 0 400 0 -- Declare the variable to be used. 0 400 0 DECLARE @MyCounter INT; 1 400 0 0 400 0 -- Initialize the variable. 0 400 0 SET @MyCounter = 0; 0 400 0 WHILE (@MyCounter < 26) 2 400 0 + BEGIN; 0 401 0 | -- Insert a row into the table. 0 401 0 | INSERT INTO TestTable VALUES 0 401 0 | -- Use the variable to provide the integer value 0 401 0 | -- for cola. Also use it to generate a unique letter 0 401 0 | -- for each row. Use the ASCII function to get the 0 401 0 | -- integer value of 'a'. Add @MyCounter. Use CHAR to 0 401 0 | -- convert the sum back to the character @MyCounter 0 401 0 | -- characters after 'a'. 0 401 0 | (@MyCounter, 0 401 0 | CHAR( ( @MyCounter + ASCII('a') ) ) 0 401 0 | ); 0 401 0 | -- Increment the variable to count this iteration 0 401 0 | -- of the loop. 0 401 0 | SET @MyCounter = @MyCounter + 1; 0 401 0 | END; 1 400 0 0 400 0 IF @@ERROR = 547 2 400 0 + BEGIN 0 401 0 | PRINT N'A check constraint violation occurred.'; 0 401 0 | END 0 400 0 GO 1 400 0 0 400 0 USE [AllStyles].[dbo].[test] 0 400 0 GO 1 400 0 0 400 0 SELECT ProductID 0 400 0 FROM Production.Product 0 400 0 INTERSECT 0 400 0 SELECT ProductID 0 400 0 FROM Production.WorkOrder ; 0 400 0 tmpok_q575y/lexilla/test/examples/mssql/Issue87.tsql.folded0000664000175000017500000000037414773064066023553 0ustar gusnangusnan 2 400 0 + /** 0 401 0 | /* 0 401 0 | GitHub Issue 87 0 401 0 | /* 0 401 0 | /****** Object: Table [dbo].[Issue87] Script Date: 04/06/2022 8:07:57 PM ******/ 0 401 0 | */ 0 401 0 | */ 0 401 0 | */ 0 400 0 tmpok_q575y/lexilla/test/examples/mssql/Issue87.tsql.styled0000664000175000017500000000021514773064066023614 0ustar gusnangusnan{1}/** /* GitHub Issue 87 /* /****** Object: Table [dbo].[Issue87] Script Date: 04/06/2022 8:07:57 PM ******/ */ */ */{0} tmpok_q575y/lexilla/test/examples/mssql/Issue90.tsql.folded0000664000175000017500000000016114773064066023537 0ustar gusnangusnan 0 400 0 CREATE TABLE TestTable ( 0 400 0 col 0 400 0 CHAR(3) 0 400 0 ); 0 400 0 tmpok_q575y/lexilla/test/examples/mssql/Issue90.tsql.styled0000664000175000017500000000014614773064066023611 0ustar gusnangusnan{9}CREATE{0} {9}TABLE{0} {6}TestTable{15} {5}({0} {6}col{15} {10}CHAR{5}({3}3{5}){0} {5});{0} tmpok_q575y/lexilla/test/examples/mssql/Various.tsql.styled0000664000175000017500000000770414773064066024007 0ustar gusnangusnan{1}/* This file contains snippets of Transact-SQL that exercise various aspects of the language. */{0} {1}/** /* AllStyles.tsql /* /****** Object: Database [AllStyles] Script Date: 06/16/2022 10:56:35 PM ******/ */ */ */{0} {9}IF{0} {5}({3}1{0} {5}={0} {6}FULLTEXTSERVICEPROPERTY{5}({4}'IsFullTextInstalled'{5})){0} {9}BEGIN{0} {6}EXEC{15} {14}sp_fulltext_database{0} {7}@action{15} {5}={0} {4}'enable'{5};{0} {9}END{0} {9}USE{0} {6}AllStyles{5};{0} {9}GO{0} {9}SELECT{0} {5}*{0} {9}FROM{0} {6}Production.Product{15} {9}ORDER{0} {9}BY{0} {6}Name{15} {6}ASC{5};{0} {2}-- Alternate way.{0} {9}USE{0} {6}AllStyles{5};{0} {9}GO{0} {9}SELECT{0} {6}p.{5}*{0} {9}FROM{0} {6}Production.Product{15} {9}AS{0} {6}p{15} {9}ORDER{0} {9}BY{0} {6}Name{15} {6}ASC{5};{0} {9}GO{0} {9}SELECT{0} {8}"COLUMN"{15} {9}FROM{0} {8}"TABLE"{15} {9}SELECT{0} {8}"COLUMN"{15} {10}int{0} {9}FROM{0} {8}"TABLE"{15} {9}SELECT{0} {6}schema_name{15} {5}({6}tab.schema_id{5}){0} {9}AS{0} {6}schema_name{15} {2}-- retrieve the name, too{0} {5},{6}tab.name{15} {9}FROM{0} {6}sys.tables{15} {9}AS{0} {6}tab{5};{0} {9}SELECT{0} {9}DISTINCT{0} {6}Name{15} {9}FROM{0} {6}Production.Product{15} {9}AS{0} {6}p{15} {9}WHERE{0} {9}EXISTS{0} {5}({9}SELECT{0} {5}*{0} {9}FROM{0} {6}Production.ProductModel{15} {9}AS{0} {6}pm{15} {9}WHERE{0} {6}p.ProductModelID{15} {5}={0} {6}pm.ProductModelID{15} {9}AND{0} {6}pm.Name{15} {9}LIKE{0} {4}'Long-Sleeve Logo Jersey%'{5});{0} {9}SELECT{0} {9}DISTINCT{0} {6}p.LastName{5},{0} {6}p.FirstName{15} {9}FROM{0} {6}Person.Person{15} {9}AS{0} {6}p{15} {9}JOIN{0} {6}HumanResources.Employee{15} {9}AS{0} {6}e{15} {9}ON{0} {6}e.BusinessEntityID{15} {5}={0} {6}p.BusinessEntityID{15} {9}WHERE{0} {3}5000.00{0} {9}IN{0} {5}({9}SELECT{0} {6}Bonus{15} {9}FROM{0} {6}Sales.SalesPerson{15} {9}AS{0} {6}sp{15} {9}WHERE{0} {6}e.BusinessEntityID{15} {5}={0} {6}sp.BusinessEntityID{5});{0} {9}CREATE{0} {9}PROCEDURE{0} {6}findjobs{0} {7}@nm{15} {6}sysname{15} {5}={0} {9}NULL{0} {9}AS{0} {9}IF{0} {7}@nm{15} {9}IS{0} {9}NULL{0} {9}BEGIN{0} {9}PRINT{0} {4}'You must give a user name'{0} {9}RETURN{0} {9}END{0} {9}ELSE{0} {9}BEGIN{0} {9}SELECT{0} {6}o.name{5},{0} {6}o.id{5},{0} {6}o.uid{15} {9}FROM{0} {11}sysobjects{0} {6}o{15} {9}INNER{0} {9}JOIN{0} {6}master.syslogins{15} {6}l{15} {9}ON{0} {6}o.uid{15} {5}={0} {6}l.sid{15} {9}WHERE{0} {6}l.name{15} {5}={0} {7}@nm{15} {9}END{5};{0} {9}CREATE{0} {9}TABLE{0} {6}TestTable{15} {5}({6}cola{15} {10}INT{5},{0} {6}colb{15} {10}CHAR{5}({3}3{5}));{0} {2}-- Declare the variable to be used.{0} {9}DECLARE{0} {7}@MyCounter{15} {10}INT{5};{0} {2}-- Initialize the variable.{0} {9}SET{0} {7}@MyCounter{15} {5}={0} {3}0{5};{0} {9}WHILE{0} {5}({7}@MyCounter{15} {5}<{0} {3}26{5}){0} {9}BEGIN{5};{0} {2}-- Insert a row into the table.{0} {9}INSERT{0} {9}INTO{0} {6}TestTable{15} {9}VALUES{0} {2}-- Use the variable to provide the integer value{0} {2}-- for cola. Also use it to generate a unique letter{0} {2}-- for each row. Use the ASCII function to get the{0} {2}-- integer value of 'a'. Add @MyCounter. Use CHAR to{0} {2}-- convert the sum back to the character @MyCounter{0} {2}-- characters after 'a'.{0} {5}({7}@MyCounter{5},{0} {13}CHAR{5}({0} {5}({0} {7}@MyCounter{15} {5}+{0} {13}ASCII{5}({4}'a'{5}){0} {5}){0} {5}){0} {5});{0} {2}-- Increment the variable to count this iteration{0} {2}-- of the loop.{0} {9}SET{0} {7}@MyCounter{15} {5}={0} {7}@MyCounter{15} {5}+{0} {3}1{5};{0} {9}END{5};{0} {9}IF{0} {12}@@ERROR{0} {5}={0} {3}547{0} {9}BEGIN{0} {9}PRINT{0} {6}N{4}'A check constraint violation occurred.'{5};{0} {9}END{0} {9}GO{0} {9}USE{0} {16}[AllStyles]{5}.{16}[dbo]{5}.{16}[test]{15} {9}GO{0} {9}SELECT{0} {6}ProductID{15} {9}FROM{0} {6}Production.Product{15} {5}INTERSECT{0} {9}SELECT{0} {6}ProductID{15} {9}FROM{0} {6}Production.WorkOrder{15} {5};{0} tmpok_q575y/lexilla/test/examples/gdscript/0000775000175000017500000000000014773064066020617 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/gdscript/SciTE.properties0000664000175000017500000000021514773064066023702 0ustar gusnangusnanlexer.*.gd=gdscript keywords.*.gd=class func else for if extends in pass print return while var keywords2.*.gd=hilight fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/gdscript/NodePath.gd0000664000175000017500000000047114773064066022637 0ustar gusnangusnan# nodepath $Node %Node %node/"n o d e"/%'n o d e' %"No de" $/root/ThisNode/%Node % %test $MainMenuPanel/%Options % %test %Options % %test $Node % %test get_node("%Options") % %test $"Nod se" % %test $/test/"No % de"/test % %test %node/"n o d e"/'n o d e' % %"No De" "%010d" % 12345 1 % 1 a % b tmpok_q575y/lexilla/test/examples/gdscript/NodePath.gd.styled0000664000175000017500000000111114773064066024132 0ustar gusnangusnan{1}# nodepath{0} {16}$Node{0} {16}%Node{0} {16}%node/"n o d e"/%'n o d e'{0} {16}%"No de"{0} {16}$/root/ThisNode/%Node{0} {10}%{0} {16}%test{0} {16}$MainMenuPanel/%Options{0} {10}%{0} {16}%test{0} {16}%Options{0} {10}%{0} {16}%test{0} {16}$Node{0} {10}%{0} {16}%test{0} {11}get_node{10}({3}"%Options"{10}){0} {10}%{0} {16}%test{0} {16}$"Nod se"{0} {10}%{0} {16}%test{0} {16}$/test/"No % de"/test{0} {10}%{0} {16}%test{0} {16}%node/"n o d e"/'n o d e'{0} {10}%{0} {16}%"No De"{0} {3}"%010d"{0} {10}%{0} {2}12345{0} {2}1{0} {10}%{0} {2}1{0} {11}a{0} {10}%{0} {11}b{0} tmpok_q575y/lexilla/test/examples/gdscript/AllStyles.gd0000664000175000017500000000110414773064066023043 0ustar gusnangusnan# Enumerate all styles: 0 to 15 # comment=1 # whitespace=0 # w # number=2 37 # double-quoted-string=3 "str" # single-quoted-string=4 'str' # keyword=5 pass # triple-quoted-string=6 '''str''' # triple-double-quoted-string=7 """str""" # class-name=8 class ClassName: pass # function-name=9 func function_name(): pass # operator=10 1 + 3 # identifier=11 var identifier = 2 # comment-block=12 ## block # unclosed-string=13 " unclosed # highlighted-identifier=14 var hilight = 2 # annotation=15 @onready var a = 3 @onready var b = 3 # node-identifier=16 %node $node tmpok_q575y/lexilla/test/examples/gdscript/AllStyles.gd.folded0000664000175000017500000000243414773064066024306 0ustar gusnangusnan 0 400 0 # Enumerate all styles: 0 to 15 0 400 0 # comment=1 1 400 0 0 400 0 # whitespace=0 0 400 0 # w 1 400 0 0 400 0 # number=2 0 400 0 37 1 400 0 0 400 0 # double-quoted-string=3 0 400 0 "str" 1 400 0 0 400 0 # single-quoted-string=4 0 400 0 'str' 1 400 0 0 400 0 # keyword=5 0 400 0 pass 1 400 0 0 400 0 # triple-quoted-string=6 0 400 0 '''str''' 1 400 0 0 400 0 # triple-double-quoted-string=7 0 400 0 """str""" 1 400 0 0 400 0 # class-name=8 2 400 0 + class ClassName: 0 408 0 | pass 1 400 0 0 400 0 # function-name=9 2 400 0 + func function_name(): 0 408 0 | pass 1 400 0 0 400 0 # operator=10 0 400 0 1 + 3 1 400 0 0 400 0 # identifier=11 0 400 0 var identifier = 2 1 400 0 0 400 0 # comment-block=12 0 400 0 ## block 1 400 0 0 400 0 # unclosed-string=13 0 400 0 " unclosed 1 400 0 0 400 0 # highlighted-identifier=14 0 400 0 var hilight = 2 1 400 0 0 400 0 # annotation=15 0 400 0 @onready 0 400 0 var a = 3 0 400 0 @onready var b = 3 1 400 0 0 400 0 # node-identifier=16 0 400 0 %node 0 400 0 $node 1 400 0 tmpok_q575y/lexilla/test/examples/gdscript/NodePath.gd.folded0000664000175000017500000000136314773064066024074 0ustar gusnangusnan 0 400 0 # nodepath 1 400 0 0 400 0 $Node 1 400 0 0 400 0 %Node 1 400 0 0 400 0 %node/"n o d e"/%'n o d e' 1 400 0 0 400 0 %"No de" 1 400 0 1 400 0 0 400 0 $/root/ThisNode/%Node % %test 1 400 0 0 400 0 $MainMenuPanel/%Options % %test 1 400 0 0 400 0 %Options % %test 1 400 0 0 400 0 $Node % %test 1 400 0 1 400 0 0 400 0 get_node("%Options") % %test 1 400 0 0 400 0 $"Nod se" % %test 1 400 0 0 400 0 $/test/"No % de"/test % %test 1 400 0 0 400 0 %node/"n o d e"/'n o d e' % %"No De" 1 400 0 0 400 0 "%010d" % 12345 1 400 0 0 400 0 1 % 1 1 400 0 0 400 0 a % b 1 400 0 tmpok_q575y/lexilla/test/examples/gdscript/AllStyles.gd.styled0000664000175000017500000000165314773064066024357 0ustar gusnangusnan{1}# Enumerate all styles: 0 to 15{0} {1}# comment=1{0} {1}# whitespace=0{0} {1}# w{0} {1}# number=2{0} {2}37{0} {1}# double-quoted-string=3{0} {3}"str"{0} {1}# single-quoted-string=4{0} {4}'str'{0} {1}# keyword=5{0} {5}pass{0} {1}# triple-quoted-string=6{0} {6}'''str'''{0} {1}# triple-double-quoted-string=7{0} {7}"""str"""{0} {1}# class-name=8{0} {5}class{0} {8}ClassName{10}:{0} {5}pass{0} {1}# function-name=9{0} {5}func{0} {9}function_name{10}():{0} {5}pass{0} {1}# operator=10{0} {2}1{0} {10}+{0} {2}3{0} {1}# identifier=11{0} {5}var{0} {11}identifier{0} {10}={0} {2}2{0} {1}# comment-block=12{0} {12}## block{0} {1}# unclosed-string=13{0} {13}" unclosed {0} {1}# highlighted-identifier=14{0} {5}var{0} {14}hilight{0} {10}={0} {2}2{0} {1}# annotation=15{0} {15}@onready{0} {5}var{0} {11}a{0} {10}={0} {2}3{0} {15}@onready{0} {5}var{0} {11}b{0} {10}={0} {2}3{0} {1}# node-identifier=16{0} {16}%node{0} {16}$node{0} tmpok_q575y/lexilla/test/examples/vb/0000775000175000017500000000000014773064066017407 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/vb/AllStyles.vbs0000664000175000017500000000102514773064066022035 0ustar gusnangusnan' coding: utf-8 ' Enumerate all styles: 0 .. 12 ' comment=1 ' whitespace=0 ' w ' number=2 37 54.3345612e7 &B01111100 &O1163 &H_E635_9A60 ' keyword=3 string ' double-quoted-string=4 "str" "a"c ' preprocessor=5 #Const preproc = True ' operator=6 - 1 ' identifier=7 identifier = 7 ' non-ASCII Ï€_is_pi_ω = 3.14 ' vb may add a type character like $ to identifiers; vbscript doesn't have this identifier$ = "s" ' date=8 d=#05/11/2003# ' unclosed-string=9 " unclosed ' keyword2=10 key2 ' keyword3=11 key3 ' keyword4=12 key4 tmpok_q575y/lexilla/test/examples/vb/AllStyles.vb.folded0000664000175000017500000000223714773064066023114 0ustar gusnangusnan 1 400 0 ' coding: utf-8 1 400 0 ' Enumerate all styles: 0 .. 12 1 400 0 1 400 0 ' comment=1 1 400 0 1 400 0 ' whitespace=0 1 408 0 | ' w 1 400 0 1 400 0 ' number=2 0 400 0 37 0 400 0 54.3345612e7 0 400 0 &B01111100 0 400 0 &O1163 0 400 0 &H_E635_9A60 1 400 0 1 400 0 ' keyword=3 0 400 0 string 1 400 0 1 400 0 ' double-quoted-string=4 0 400 0 "str" 0 400 0 "a"c 1 400 0 1 400 0 ' preprocessor=5 0 400 0 #Const preproc = True 1 400 0 1 400 0 ' operator=6 0 400 0 - 1 1 400 0 1 400 0 ' identifier=7 0 400 0 identifier = 7 1 400 0 ' non-ASCII 0 400 0 Ï€_is_pi_ω = 3.14 1 400 0 ' vb may add a type character like $ to identifiers; vbscript doesn't have this 0 400 0 identifier$ = "s" 1 400 0 1 400 0 ' date=8 0 400 0 d=#05/11/2003# 1 400 0 1 400 0 ' unclosed-string=9 0 400 0 " unclosed 1 400 0 1 400 0 ' keyword2=10 0 400 0 key2 1 400 0 1 400 0 ' keyword3=11 0 400 0 key3 1 400 0 1 400 0 ' keyword4=12 0 400 0 key4 0 400 0 tmpok_q575y/lexilla/test/examples/vb/SciTE.properties0000664000175000017500000000042014773064066022470 0ustar gusnangusnanlexer.*.vb=vb keywords.*.vb=as dim or string keywords2.*.vb=key2 keywords3.*.vb=key3 keywords4.*.vb=key4 lexer.*.vbs=vbscript keywords.*.vbs=as dim or string keywords2.*.vbs=key2 keywords3.*.vbs=key3 keywords4.*.vbs=key4 fold=1 match x.vb lexer.vb.strings.multiline=1 tmpok_q575y/lexilla/test/examples/vb/AllStyles.vbs.folded0000664000175000017500000000223714773064066023277 0ustar gusnangusnan 1 400 0 ' coding: utf-8 1 400 0 ' Enumerate all styles: 0 .. 12 1 400 0 1 400 0 ' comment=1 1 400 0 1 400 0 ' whitespace=0 1 408 0 | ' w 1 400 0 1 400 0 ' number=2 0 400 0 37 0 400 0 54.3345612e7 0 400 0 &B01111100 0 400 0 &O1163 0 400 0 &H_E635_9A60 1 400 0 1 400 0 ' keyword=3 0 400 0 string 1 400 0 1 400 0 ' double-quoted-string=4 0 400 0 "str" 0 400 0 "a"c 1 400 0 1 400 0 ' preprocessor=5 0 400 0 #Const preproc = True 1 400 0 1 400 0 ' operator=6 0 400 0 - 1 1 400 0 1 400 0 ' identifier=7 0 400 0 identifier = 7 1 400 0 ' non-ASCII 0 400 0 Ï€_is_pi_ω = 3.14 1 400 0 ' vb may add a type character like $ to identifiers; vbscript doesn't have this 0 400 0 identifier$ = "s" 1 400 0 1 400 0 ' date=8 0 400 0 d=#05/11/2003# 1 400 0 1 400 0 ' unclosed-string=9 0 400 0 " unclosed 1 400 0 1 400 0 ' keyword2=10 0 400 0 key2 1 400 0 1 400 0 ' keyword3=11 0 400 0 key3 1 400 0 1 400 0 ' keyword4=12 0 400 0 key4 0 400 0 tmpok_q575y/lexilla/test/examples/vb/x.vb0000664000175000017500000000053614773064066020213 0ustar gusnangusnan' String" Dim a As String = "hello, world" Dim b As String = "hello world" Dim c As String = "Joe said ""Hello"" to me" Dim d As String = "\\\\server\\share\\file.txt" Dim e As String = "The brown fox jumps over the lazy dog" ' Character ""C "c"C "cc"C ' Date d = #5/31/1993# or # 01/01/0001 12:00:00AM # ' Number 123_456___789 123_ &b10101_01010 tmpok_q575y/lexilla/test/examples/vb/x.vb.styled0000664000175000017500000000114014773064066021506 0ustar gusnangusnan{1}' String" {3}Dim{0} {7}a{0} {3}As{0} {3}String{0} {6}={0} {4}"hello, world"{0} {3}Dim{0} {7}b{0} {3}As{0} {3}String{0} {6}={0} {4}"hello world"{0} {3}Dim{0} {7}c{0} {3}As{0} {3}String{0} {6}={0} {4}"Joe said ""Hello"" to me"{0} {3}Dim{0} {7}d{0} {3}As{0} {3}String{0} {6}={0} {4}"\\\\server\\share\\file.txt"{0} {3}Dim{0} {7}e{0} {3}As{0} {3}String{0} {6}={0} {4}"The brown fox jumps over the lazy dog"{0} {1}' Character {4}""C{0} {4}"c"C{0} {4}"cc"C{0} {1}' Date {7}d{0} {6}={0} {8}#5/31/1993#{0} {3}or{0} {8}# 01/01/0001 12:00:00AM #{0} {1}' Number {2}123_456___789{0} {2}123_{0} {2}&b10101_01010{0} tmpok_q575y/lexilla/test/examples/vb/x.vb.folded0000664000175000017500000000107314773064066021444 0ustar gusnangusnan 1 400 0 ' String" 0 400 0 Dim a As String = "hello, world" 0 400 0 Dim b As String = "hello world" 0 400 0 Dim c As String = "Joe said ""Hello"" to me" 0 400 0 Dim d As String = "\\\\server\\share\\file.txt" 0 400 0 Dim e As String = "The brown fox 0 400 0 jumps over 0 400 0 the lazy dog" 1 400 0 ' Character 0 400 0 ""C "c"C "cc"C 1 400 0 ' Date 0 400 0 d = #5/31/1993# or # 01/01/0001 12:00:00AM # 1 400 0 ' Number 0 400 0 123_456___789 0 400 0 123_ 0 400 0 &b10101_01010 0 400 0 tmpok_q575y/lexilla/test/examples/vb/AllStyles.vb.styled0000664000175000017500000000136314773064066023162 0ustar gusnangusnan{1}' coding: utf-8 ' Enumerate all styles: 0 .. 12 {0} {1}' comment=1 {0} {1}' whitespace=0 {0} {1}' w {0} {1}' number=2 {2}37{0} {2}54.3345612e7{0} {2}&B01111100{0} {2}&O1163{0} {2}&H_E635_9A60{0} {1}' keyword=3 {3}string{0} {1}' double-quoted-string=4 {4}"str"{0} {4}"a"c{0} {1}' preprocessor=5 {5}#Const preproc = True {0} {1}' operator=6 {6}-{0} {2}1{0} {1}' identifier=7 {7}identifier{0} {6}={0} {2}7{0} {1}' non-ASCII {7}Ï€_is_pi_ω{0} {6}={0} {2}3.14{0} {1}' vb may add a type character like $ to identifiers; vbscript doesn't have this {7}identifier${0} {6}={0} {4}"s"{0} {1}' date=8 {7}d{6}={8}#05/11/2003#{0} {1}' unclosed-string=9 {9}" unclosed {0} {1}' keyword2=10 {10}key2{0} {1}' keyword3=11 {11}key3{0} {1}' keyword4=12 {12}key4{0} tmpok_q575y/lexilla/test/examples/vb/AllStyles.vbs.styled0000664000175000017500000000136314773064066023345 0ustar gusnangusnan{1}' coding: utf-8 ' Enumerate all styles: 0 .. 12 {0} {1}' comment=1 {0} {1}' whitespace=0 {0} {1}' w {0} {1}' number=2 {2}37{0} {2}54.3345612e7{0} {2}&B01111100{0} {2}&O1163{0} {2}&H_E635_9A60{0} {1}' keyword=3 {3}string{0} {1}' double-quoted-string=4 {4}"str"{0} {4}"a"c{0} {1}' preprocessor=5 {5}#Const preproc = True {0} {1}' operator=6 {6}-{0} {2}1{0} {1}' identifier=7 {7}identifier{0} {6}={0} {2}7{0} {1}' non-ASCII {7}Ï€_is_pi_ω{0} {6}={0} {2}3.14{0} {1}' vb may add a type character like $ to identifiers; vbscript doesn't have this {7}identifier{0}$ {6}={0} {4}"s"{0} {1}' date=8 {7}d{6}={8}#05/11/2003#{0} {1}' unclosed-string=9 {9}" unclosed {0} {1}' keyword2=10 {10}key2{0} {1}' keyword3=11 {11}key3{0} {1}' keyword4=12 {12}key4{0} tmpok_q575y/lexilla/test/examples/vb/AllStyles.vb0000664000175000017500000000102514773064066021652 0ustar gusnangusnan' coding: utf-8 ' Enumerate all styles: 0 .. 12 ' comment=1 ' whitespace=0 ' w ' number=2 37 54.3345612e7 &B01111100 &O1163 &H_E635_9A60 ' keyword=3 string ' double-quoted-string=4 "str" "a"c ' preprocessor=5 #Const preproc = True ' operator=6 - 1 ' identifier=7 identifier = 7 ' non-ASCII Ï€_is_pi_ω = 3.14 ' vb may add a type character like $ to identifiers; vbscript doesn't have this identifier$ = "s" ' date=8 d=#05/11/2003# ' unclosed-string=9 " unclosed ' keyword2=10 key2 ' keyword3=11 key3 ' keyword4=12 key4 tmpok_q575y/lexilla/test/examples/julia/0000775000175000017500000000000014773064066020104 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/julia/x.jl0000664000175000017500000000051714773064066020705 0ustar gusnangusnan # Comment here const bar = '\n' """ test_fun(a::Int) For test only """ function test_fun(a::Int, b::T) where T <: Number println(a) println("foo $(bar)") end @enum Unicode α=1 β=2 res = [√i for i in 1:10] ∀=1; ∃=2; ∄=3; t!'#' t!='#' t[]!='#' #= Dummy function =# test_fun²(:sym, true, raw"test", `echo 1`) tmpok_q575y/lexilla/test/examples/julia/SciTE.properties0000664000175000017500000000021314773064066023165 0ustar gusnangusnanlexer.*.jl=julia keywords.*.jl=const end for function in where keywords2.*.jl=Int Number keywords3.*.jl=true testlexers.per.line.disable=1 tmpok_q575y/lexilla/test/examples/julia/x.jl.folded0000664000175000017500000000122414773064066022135 0ustar gusnangusnan 0 400 400 0 400 400 # Comment here 0 400 400 const bar = '\n' 0 400 400 2 400 401 + """ 0 401 401 | test_fun(a::Int) 0 401 401 | For test only 0 401 400 | """ 2 400 401 + function test_fun(a::Int, b::T) where T <: Number 0 401 401 | println(a) 0 401 401 | println("foo $(bar)") 0 401 400 | end 0 400 400 0 400 400 @enum Unicode α=1 β=2 0 400 400 0 400 400 res = [√i for i in 1:10] 0 400 400 ∀=1; ∃=2; ∄=3; 0 400 400 0 400 400 t!'#' 0 400 400 t!='#' 0 400 400 t[]!='#' 0 400 400 0 400 400 #= Dummy function =# 0 400 400 test_fun²(:sym, true, raw"test", `echo 1`) 1 400 400 tmpok_q575y/lexilla/test/examples/julia/x.jl.styled0000664000175000017500000000132214773064066022203 0ustar gusnangusnan{0} {1}# Comment here{0} {3}const{0} {9}bar{0} {7}={0} {6}'\n'{0} {14}""" test_fun(a::Int) For test only """{0} {3}function{0} {9}test_fun{8}({9}a{21}::{4}Int{7},{0} {9}b{21}::{9}T{8}){0} {3}where{0} {9}T{0} {21}<:{0} {4}Number{0} {9}println{8}({9}a{8}){0} {9}println{8}({10}"foo {13}$(bar){10}"{8}){0} {3}end{0} {12}@enum{0} {9}Unicode{0} {9}α{7}={2}1{0} {9}β{7}={2}2{0} {9}res{0} {7}={0} {8}[{7}√{9}i{0} {3}for{0} {9}i{0} {3}in{0} {2}1{7}:{2}10{8}]{0} {9}∀{7}={2}1{7};{0} {9}∃{7}={2}2{7};{0} {9}∄{7}={2}3{7};{0} {9}t!{7}'{1}#'{0} {9}t!{7}={6}'#'{0} {9}t{8}[]{7}!={6}'#'{0} {1}#= Dummy function =#{0} {9}test_fun²{8}({11}:sym{7},{0} {5}true{7},{0} {15}raw{10}"test"{7},{0} {16}`echo 1`{8}){0} tmpok_q575y/lexilla/test/examples/sql/0000775000175000017500000000000014773064066017577 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/sql/AllStyles.sql.folded0000664000175000017500000000313014773064066023465 0ustar gusnangusnan 0 400 400 -- Enumerate all styles: 0 to 24 1 400 400 0 400 400 -- comment=1 0 400 400 /* comment */ 1 400 400 0 400 400 -- whitespace=0 0 400 400 -- w 1 400 400 0 400 400 /* commentline=2 */ 0 400 400 -- commentline 1 400 400 0 400 400 -- commentdoc=3 0 400 400 /** commentdoc */ 1 400 400 0 400 400 -- number=4 0 400 400 4 1 400 400 0 400 400 -- word=5 0 400 400 select 1 400 400 0 400 400 -- string=6 0 400 400 "string" 1 400 400 0 400 400 -- character=7 0 400 400 'character' 1 400 400 0 400 400 -- sqlplus=8 0 400 400 append 1 400 400 0 400 400 -- sqlplus_prompt=9 0 400 400 prompt SQL+Prompt 1 400 400 0 400 400 -- operator=10 0 400 400 + 1 400 400 0 400 400 -- identifier=11 0 400 400 identifier 1 400 400 0 400 400 -- sqlplus_comment=13 0 400 400 remark sqlplus comment 1 400 400 0 400 400 -- commentlinedoc=15 0 400 400 # commentlinedoc 1 400 400 0 400 400 -- word2=16 0 400 400 object 1 400 400 0 400 400 -- commentdockeyword=17 0 400 400 /** @return */ 1 400 400 0 400 400 -- commentdockeyworderror=18 0 400 400 /** @error */ 1 400 400 0 400 400 -- user1=19 0 400 400 dbms_output.disable 1 400 400 0 400 400 -- user2=20 0 400 400 analyze 1 400 400 0 400 400 -- user3=21 0 400 400 array 1 400 400 0 400 400 -- user4=22 0 400 400 false 1 400 400 0 400 400 -- quotedidentifier=23 0 400 400 `quotedidentifier` 1 400 400 0 400 400 -- qoperator=24 0 400 400 q'{ today's }' 0 400 0 tmpok_q575y/lexilla/test/examples/sql/SciTE.properties0000664000175000017500000000053314773064066022665 0ustar gusnangusnanlexer.*.sql=sql keywords.*.sql=select keywords2.*.sql=object keywords3.*.sql=return keywords4.*.sql=a~ppend pro~mpt rem~ark keywords5.*.sql=dbms_output.disable keywords6.*.sql=analyze keywords7.*.sql=array keywords8.*.sql=false lexer.sql.backticks.identifier=1 lexer.sql.numbersign.comment=1 lexer.sql.allow.dotted.word=1 fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/sql/AllStyles.sql.styled0000664000175000017500000000166714773064066023551 0ustar gusnangusnan{2}-- Enumerate all styles: 0 to 24 {0} {2}-- comment=1 {1}/* comment */{0} {2}-- whitespace=0 {0} {2}-- w {0} {1}/* commentline=2 */{0} {2}-- commentline {0} {2}-- commentdoc=3 {3}/** commentdoc */{0} {2}-- number=4 {4}4{0} {2}-- word=5 {5}select{0} {2}-- string=6 {6}"string"{0} {2}-- character=7 {7}'character'{0} {2}-- sqlplus=8 {8}append{0} {2}-- sqlplus_prompt=9 {8}prompt{9} SQL+Prompt {0} {2}-- operator=10 {10}+{0} {2}-- identifier=11 {11}identifier{0} {2}-- sqlplus_comment=13 {8}remark{13} sqlplus comment {0} {2}-- commentlinedoc=15 {15}# commentlinedoc {0} {2}-- word2=16 {16}object{0} {2}-- commentdockeyword=17 {3}/** {17}@return{3} */{0} {2}-- commentdockeyworderror=18 {3}/** {18}@error{3} */{0} {2}-- user1=19 {19}dbms_output.disable{0} {2}-- user2=20 {20}analyze{0} {2}-- user3=21 {21}array{0} {2}-- user4=22 {22}false{0} {2}-- quotedidentifier=23 {23}`quotedidentifier`{0} {2}-- qoperator=24 {24}q'{ today's }'{0} tmpok_q575y/lexilla/test/examples/sql/AllStyles.sql0000664000175000017500000000127514773064066022241 0ustar gusnangusnan-- Enumerate all styles: 0 to 24 -- comment=1 /* comment */ -- whitespace=0 -- w /* commentline=2 */ -- commentline -- commentdoc=3 /** commentdoc */ -- number=4 4 -- word=5 select -- string=6 "string" -- character=7 'character' -- sqlplus=8 append -- sqlplus_prompt=9 prompt SQL+Prompt -- operator=10 + -- identifier=11 identifier -- sqlplus_comment=13 remark sqlplus comment -- commentlinedoc=15 # commentlinedoc -- word2=16 object -- commentdockeyword=17 /** @return */ -- commentdockeyworderror=18 /** @error */ -- user1=19 dbms_output.disable -- user2=20 analyze -- user3=21 array -- user4=22 false -- quotedidentifier=23 `quotedidentifier` -- qoperator=24 q'{ today's }' tmpok_q575y/lexilla/test/examples/cobol/0000775000175000017500000000000014773064066020076 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/cobol/230.cob.folded0000664000175000017500000000040414773064066022321 0ustar gusnangusnan 0 400 0 * Keywords starting with V to be identified and styled 0 400 0 0 400 0 * in list keywords2 0 400 0 VARIANCE 0 400 0 0 400 0 * in list keywords3 0 400 0 VARYING 0 400 0 tmpok_q575y/lexilla/test/examples/cobol/230.cob0000664000175000017500000000023414773064066021066 0ustar gusnangusnan * Keywords starting with V to be identified and styled * in list keywords2 VARIANCE * in list keywords3 VARYING tmpok_q575y/lexilla/test/examples/cobol/AllStyles.cob.folded0000664000175000017500000000207014773064066023732 0ustar gusnangusnan 0 400 0 * Enumerate all styles: 0, 2 to 11, 16 0 400 0 * SCE_C_COMMENTLINE=2 0 400 0 0 400 0 * SCE_C_DEFAULT=0 0 400 0 0 400 0 0 400 0 * SCE_C_IDENTIFIER=11 0 400 0 identifier 0 400 0 0 400 0 * SCE_C_NUMBER=4 0 400 0 4 0 400 0 0 400 0 * SCE_C_WORD=5 0 400 0 data 0 400 0 0 400 0 * SCE_C_WORD2=16 0 400 0 cancel 0 400 0 0 400 0 * SCE_C_UUID=8 0 400 0 remarks 0 400 0 0 400 0 * SCE_C_COMMENTDOC=3 not implemented 0 400 0 ** at line start 0 400 0 0 400 0 * SCE_C_STRING=6 0 400 0 "string" 0 400 0 0 400 0 * SCE_C_CHARACTER=7 0 400 0 'c' 0 400 0 0 400 0 * SCE_C_PREPROCESSOR=9 0 400 0 ?preprocessor 0 400 0 0 400 0 * SCE_C_OPERATOR=10 0 400 0 + 0 400 0 tmpok_q575y/lexilla/test/examples/cobol/AllStyles.cob0000664000175000017500000000114414773064066022477 0ustar gusnangusnan * Enumerate all styles: 0, 2 to 11, 16 * SCE_C_COMMENTLINE=2 * SCE_C_DEFAULT=0 * SCE_C_IDENTIFIER=11 identifier * SCE_C_NUMBER=4 4 * SCE_C_WORD=5 data * SCE_C_WORD2=16 cancel * SCE_C_UUID=8 remarks * SCE_C_COMMENTDOC=3 not implemented ** at line start * SCE_C_STRING=6 "string" * SCE_C_CHARACTER=7 'c' * SCE_C_PREPROCESSOR=9 ?preprocessor * SCE_C_OPERATOR=10 + tmpok_q575y/lexilla/test/examples/cobol/SciTE.properties0000664000175000017500000000014614773064066023164 0ustar gusnangusnanlexer.*.cob=COBOL keywords.*.cob=data keywords2.*.cob=cancel variance keywords3.*.cob=remarks varying tmpok_q575y/lexilla/test/examples/cobol/231.cob.folded0000664000175000017500000000067314773064066022332 0ustar gusnangusnan 0 400 0 * Comment preceded by 6 characters to be styled 0 400 0 * Include / to be styled as a comment 0 400 0 0 400 0 * Comment colored in green 0 400 0 ABCDE * Comment colored in green 0 400 0 ABCDEF* Comment NOT colored in green 0 400 0 / Comment NOT colored in green 0 400 0 ABCDE / Comment NOT colored in green 0 400 0 ABCDEF/ Comment NOT colored in green 0 400 0 tmpok_q575y/lexilla/test/examples/cobol/231.cob.styled0000664000175000017500000000060214773064066022371 0ustar gusnangusnan{0} {2}* Comment preceded by 6 characters to be styled{0} {2}* Include / to be styled as a comment{0} {2}* Comment colored in green{0} {11}ABCDE{0} {2}* Comment colored in green{0} {11}ABCDEF{2}* Comment NOT colored in green{0} {2}/ Comment NOT colored in green{0} {11}ABCDE{0} {2}/ Comment NOT colored in green{0} {11}ABCDEF{2}/ Comment NOT colored in green{0} tmpok_q575y/lexilla/test/examples/cobol/231.cob0000664000175000017500000000047114773064066021072 0ustar gusnangusnan * Comment preceded by 6 characters to be styled * Include / to be styled as a comment * Comment colored in green ABCDE * Comment colored in green ABCDEF* Comment NOT colored in green / Comment NOT colored in green ABCDE / Comment NOT colored in green ABCDEF/ Comment NOT colored in green tmpok_q575y/lexilla/test/examples/cobol/229.cob.folded0000664000175000017500000000107514773064066022336 0ustar gusnangusnan 0 400 0 * Fix string style to not continue to next line 0 400 0 0 400 0 DISPLAY MESSAGE BOX 0 400 0 "The following process must be applied to Earnings, Deduct 0 400 0 - "ions and Company Contributions separately." 0 400 0 0 400 0 LP61A DISPLAY MESSAGE BOX 0 400 0 lp61b "S*** strives to continually develop and improve its pr 0 400 0 LP61B - "oducts and services to deliver more value to our custo 0 400 0 LP61B - "mers." 0 400 0 tmpok_q575y/lexilla/test/examples/cobol/229.cob.styled0000664000175000017500000000106014773064066022377 0ustar gusnangusnan{0} {2}* Fix string style to not continue to next line{0} {11}DISPLAY{0} {11}MESSAGE{0} {11}BOX{0} {6}"The following process must be applied to Earnings, Deduct{0} {10}-{0} {6}"ions and Company Contributions separately."{0} {11}LP61A{0} {11}DISPLAY{0} {11}MESSAGE{0} {11}BOX{0} {11}lp61b{0} {6}"S*** strives to continually develop and improve its pr{0} {11}LP61B{0} {10}-{0} {6}"oducts and services to deliver more value to our custo{0} {11}LP61B{0} {10}-{0} {6}"mers."{0} tmpok_q575y/lexilla/test/examples/cobol/AllStyles.cob.styled0000664000175000017500000000136414773064066024006 0ustar gusnangusnan{0} {2}* Enumerate all styles: 0, 2 to 11, 16{0} {2}* SCE_C_COMMENTLINE=2{0} {2}* SCE_C_DEFAULT=0{0} {2}* SCE_C_IDENTIFIER=11{0} {11}identifier{0} {2}* SCE_C_NUMBER=4{0} {4}4{0} {2}* SCE_C_WORD=5{0} {5}data{0} {2}* SCE_C_WORD2=16{0} {16}cancel{0} {2}* SCE_C_UUID=8{0} {8}remarks{0} {2}* SCE_C_COMMENTDOC=3 not implemented{0} {3}** at line start{0} {2}* SCE_C_STRING=6{0} {6}"string"{0} {2}* SCE_C_CHARACTER=7{0} {7}'c'{0} {2}* SCE_C_PREPROCESSOR=9{0} {9}?preprocessor{0} {2}* SCE_C_OPERATOR=10{0} {10}+{0} tmpok_q575y/lexilla/test/examples/cobol/229.cob0000664000175000017500000000065614773064066021106 0ustar gusnangusnan * Fix string style to not continue to next line DISPLAY MESSAGE BOX "The following process must be applied to Earnings, Deduct - "ions and Company Contributions separately." LP61A DISPLAY MESSAGE BOX lp61b "S*** strives to continually develop and improve its pr LP61B - "oducts and services to deliver more value to our custo LP61B - "mers." tmpok_q575y/lexilla/test/examples/cobol/230.cob.styled0000664000175000017500000000027614773064066022377 0ustar gusnangusnan{0} {2}* Keywords starting with V to be identified and styled{0} {2}* in list keywords2{0} {16}VARIANCE{0} {2}* in list keywords3{0} {8}VARYING{0} tmpok_q575y/lexilla/test/examples/asciidoc/0000775000175000017500000000000014773064066020556 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/asciidoc/SciTE.properties0000664000175000017500000000005514773064066023643 0ustar gusnangusnancode.page=65001 lexer.*.adoc=asciidoc fold=1 tmpok_q575y/lexilla/test/examples/asciidoc/AllStyles.adoc.folded0000664000175000017500000000307614773064066024564 0ustar gusnangusnan 0 400 0 Text=0 0 400 0 *Strong Emphasis (bold) 1=1* 0 400 0 **Strong Emphasis (bold) 2=2** 0 400 0 _Emphasis (italic) 1=3_ 0 400 0 __Emphasis (italic) 2=4__ 0 400 0 = Heading level 1=5 0 400 0 == Heading level 2=6 0 400 0 === Heading level 3=7 0 400 0 ==== Heading level 4=8 0 400 0 ===== Heading level 5=9 0 400 0 ====== Heading level 6=10 0 400 0 * Unordered list item=11 0 400 0 . Ordered list item=12 0 400 0 > Block quote=13 0 400 0 https://14.com[Link=14] 0 400 0 ---- 0 400 0 Code block=15 0 400 0 ---- 0 400 0 ++++ 0 400 0 Passthrough block=16 0 400 0 ++++ 0 400 0 // Comment=17 0 400 0 //// 0 400 0 Comment Block=18 0 400 0 //// 0 400 0 +Literal=19+ 0 400 0 .... 0 400 0 Literal Block=20 0 400 0 .... 0 400 0 :Attrib=21: Attrib Value=22 0 400 0 ifdef::Macro=23 0 400 0 ifeval::Macro=23 0 400 0 ifndef::Macro=23 0 400 0 endif::Macro=23 0 400 0 audio::Macro=23 0 400 0 include::Macro=23 0 400 0 image::Macro=23 0 400 0 video::Macro=23 0 400 0 asciimath:Macro=23 0 400 0 btn:Macro=23 0 400 0 image:Macro=23 0 400 0 kbd:Macro=23 0 400 0 latexmath:Macro=23 0 400 0 link:Macro=23 0 400 0 mailto:Macro=23 0 400 0 menu:Macro=23 0 400 0 pass:Macro=23 0 400 0 stem:Macro=23 0 400 0 xref:Macro=23 0 400 0 CAUTION:Macro=23 0 400 0 IMPORTANT:Macro=23 0 400 0 NOTE:Macro=23 0 400 0 TIP:Macro=23 0 400 0 WARNING:Macro=23 0 400 0 tmpok_q575y/lexilla/test/examples/asciidoc/AllStyles.adoc0000664000175000017500000000156314773064066023327 0ustar gusnangusnanText=0 *Strong Emphasis (bold) 1=1* **Strong Emphasis (bold) 2=2** _Emphasis (italic) 1=3_ __Emphasis (italic) 2=4__ = Heading level 1=5 == Heading level 2=6 === Heading level 3=7 ==== Heading level 4=8 ===== Heading level 5=9 ====== Heading level 6=10 * Unordered list item=11 . Ordered list item=12 > Block quote=13 https://14.com[Link=14] ---- Code block=15 ---- ++++ Passthrough block=16 ++++ // Comment=17 //// Comment Block=18 //// +Literal=19+ .... Literal Block=20 .... :Attrib=21: Attrib Value=22 ifdef::Macro=23 ifeval::Macro=23 ifndef::Macro=23 endif::Macro=23 audio::Macro=23 include::Macro=23 image::Macro=23 video::Macro=23 asciimath:Macro=23 btn:Macro=23 image:Macro=23 kbd:Macro=23 latexmath:Macro=23 link:Macro=23 mailto:Macro=23 menu:Macro=23 pass:Macro=23 stem:Macro=23 xref:Macro=23 CAUTION:Macro=23 IMPORTANT:Macro=23 NOTE:Macro=23 TIP:Macro=23 WARNING:Macro=23 tmpok_q575y/lexilla/test/examples/asciidoc/AllStyles.adoc.styled0000664000175000017500000000225414773064066024630 0ustar gusnangusnan{0}Text=0 {1}*Strong Emphasis (bold) 1=1*{0} {2}**Strong Emphasis (bold) 2=2**{0} {3}_Emphasis (italic) 1=3_{0} {4}__Emphasis (italic) 2=4__{0} {5}= Heading level 1=5{0} {6}== Heading level 2=6{0} {7}=== Heading level 3=7{0} {8}==== Heading level 4=8{0} {9}===== Heading level 5=9{0} {10}====== Heading level 6=10{0} {11}*{0} Unordered list item=11 {12}.{0} Ordered list item=12 {13}> Block quote=13{0} https://14.com[{14}Link=14{0}] {15}---- Code block=15 ----{0} {16}++++ Passthrough block=16 ++++{0} {17}// Comment=17{0} {18}//// Comment Block=18 ////{0} +{19}Literal=19{0}+ {20}.... Literal Block=20 ....{0} {21}:Attrib=21:{22} Attrib Value=22{0} {23}ifdef{0}::Macro=23 {23}ifeval{0}::Macro=23 {23}ifndef{0}::Macro=23 {23}endif{0}::Macro=23 {23}audio{0}::Macro=23 {23}include{0}::Macro=23 {23}image{0}::Macro=23 {23}video{0}::Macro=23 {23}asciimat{0}h:Macro=23 {23}btn{0}:Macro=23 {23}image{0}:Macro=23 {23}kbd{0}:Macro=23 {23}latexmath{0}:Macro=23 {23}link{0}:Macro=23 {23}mailto{0}:Macro=23 {23}menu{0}:Macro=23 {23}pass{0}:Macro=23 {23}stem{0}:Macro=23 {23}xref{0}:Macro=23 {23}CAUTION{0}:Macro=23 {23}IMPORTANT{0}:Macro=23 {23}NOTE{0}:Macro=23 {23}TIP{0}:Macro=23 {23}WARNING{0}:Macro=23 tmpok_q575y/lexilla/test/examples/cpp/0000775000175000017500000000000014773064066017562 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/cpp/Bug2245.cxx.folded0000664000175000017500000000037614773064066022602 0ustar gusnangusnan 0 400 400 int i; 2 400 401 + #if 1 0 401 401 | i=1; 0 401 401 | # 0 401 401 | i=2; 0 401 401 | #else 0 401 401 | i=3; 0 401 400 | #endif 0 400 400 i=4; 0 400 400 #elif 1 0 400 400 i=5; 0 400 400 #else 0 400 400 i=6; 1 400 400 tmpok_q575y/lexilla/test/examples/cpp/130NonAsciiKeyword.cxx.folded0000664000175000017500000000044114773064066025035 0ustar gusnangusnan 0 400 400 // coding: utf-8 0 400 400 // All three following symbols should highlight as keywords 0 400 400 cheese 0 400 400 käse 0 400 400 ÑÑ‹Ñ€ 1 400 400 0 400 400 // Lookalikes with ASCII so should not highlight: 0 400 400 ÑÑ‹p 0 400 400 cÑ‹p 1 400 400 tmpok_q575y/lexilla/test/examples/cpp/Bug2245.cxx0000664000175000017500000000011014773064066021330 0ustar gusnangusnanint i; #if 1 i=1; # i=2; #else i=3; #endif i=4; #elif 1 i=5; #else i=6; tmpok_q575y/lexilla/test/examples/cpp/94Template.cxx0000664000175000017500000000136714773064066022245 0ustar gusnangusnan// Test JavaScript template expressions for issue 94 // Basic var basic = `${identifier}`; // Nested var nested = ` ${ ` ${ 1 } ` } `; // With escapes var xxx = { '1': `\`\u0020\${a${1 + 1}b}`, '2': `\${a${ `b${1 + 2}c`.charCodeAt(2) }d}`, '3': `\${a${ `b${ `c${ JSON.stringify({ '4': {}, }) }d` }e` }f}`, }; // Original request fetchOptions.body = ` { "accountNumber" : "248796", "customerType" : "Shipper", "destinationCity" : "${order.destination.city}", "destinationState" : "${order.destination.stateProvince}", "destinationZip" : ${order.destination.postalCode}, "paymentType" : "Prepaid", "shipmentInfo" : { "items" : [ { "shipmentClass" : "50", "shipmentWeight" : "${order.totalWeight.toString()}" } ] } }`; tmpok_q575y/lexilla/test/examples/cpp/SciTE.properties0000664000175000017500000000136114773064066022650 0ustar gusnangusnan# coding: utf-8 lexer.*.cxx=cpp keywords.*.cxx=int let uuid var keywords2.*.cxx=charCodeAt second stringify Upper keywords3.*.cxx=file keywords4.*.cxx=global JSON keywords5.*.cxx=HAVE_COLOUR FEATURE=2 VERSION(a,b)=a+b keywords6.*.cxx=TODO substyles.cpp.11=2 substylewords.11.1.*.cxx=map string vector substylewords.11.2.*.cxx=std gsl substyles.cpp.17=1 substylewords.17.1.*.cxx=module lexer.cpp.track.preprocessor=1 lexer.cpp.escape.sequence=1 # Set options so that AllStyles.cxx can show every style styling.within.preprocessor=0 lexer.cpp.triplequoted.strings=1 lexer.cpp.hashquoted.strings=1 lexer.cpp.backquoted.strings=2 fold=1 fold.preprocessor=1 fold.comment=1 fold.compact=1 match 130NonAsciiKeyword.cxx keywords.*.cxx=cheese käse ÑÑ‹Ñ€ tmpok_q575y/lexilla/test/examples/cpp/AllStyles.cxx0000664000175000017500000000403014773064066022217 0ustar gusnangusnan// Enumerate all primary styles: 0 to 27 and secondary styles 64 to 91 // default=0 // comment=1 /* */ /* commentline=2 */ // example line // commentdoc=3 /** */ // number=4 123 // word=5 int // string=6 "string" // character=7 'c' // uuid=8 uuid(3fd43029-1354-42f0-a5be-4a484c9c5250) // preprocessor=9 #define xxx 1 // operator=10 {} // identifier=11 identifier // stringeol=12 " // verbatim=13 @"verbatim" // regex=14 (/regex/) // commentlinedoc=15 /// example // word2=16 second // commentdockeyword=17 /** @file */ // commentdockeyworderror=18 /** @wrongkey */ // globalclass=19 global // stringraw=20 R"( )" // tripleverbatim=21 """ xx """ // hashquotedstring=22 #" xx " // preprocessorcomment=23 #define /* comment */ // preprocessorcommentdoc=24 #define /** comment */ // userliteral=25 1_date_ // taskmarker=26 /* TODO: sleep */ // escapesequence=27 "\001 \b" // identifier substyles.11.1=128 vector // identifier substyles.11.2=129 std // commentdockeyword substyles.17.1=130 /** @module */ // Secondary styles inside preprocessor excluded section #if 0 // default=0 // comment=1 /* */ /* commentline=2 */ // example line // commentdoc=3 /** */ // number=4 123 // word=5 int // string=6 "string" // character=7 'c' // uuid=8 uuid(3fd43029-1354-42f0-a5be-4a484c9c5250) // preprocessor=9 #define xxx 1 // operator=10 {} // identifier=11 identifier // stringeol=12 " // verbatim=13 @"verbatim" // regex=14 (/regex/) // commentlinedoc=15 /// example // word2=16 second // commentdockeyword=17 /** @file */ // commentdockeyworderror=18 /** @wrongkey */ // globalclass=19 global // stringraw=20 R"( )" // tripleverbatim=21 """ xx """ // hashquotedstring=22 #" xx " // preprocessorcomment=23 #define /* comment */ // preprocessorcommentdoc=24 #define /** comment */ // userliteral=25 1_date_ // taskmarker=26 /* TODO: sleep */ // escapesequence=27 "\001 \b" // identifier substyles.75.1=192 vector // identifier substyles.75.2=193 std // commentdockeyword substyles.81.1=194 /** @module */ #endif tmpok_q575y/lexilla/test/examples/cpp/94Template.cxx.folded0000664000175000017500000000222714773064066023475 0ustar gusnangusnan 0 400 400 // Test JavaScript template expressions for issue 94 1 400 400 0 400 400 // Basic 0 400 400 var basic = `${identifier}`; 1 400 400 0 400 400 // Nested 0 400 400 var nested = ` ${ ` ${ 1 } ` } `; 1 400 400 0 400 400 // With escapes 2 400 401 + var xxx = { 0 401 401 | '1': `\`\u0020\${a${1 + 1}b}`, 0 401 401 | '2': `\${a${ `b${1 + 2}c`.charCodeAt(2) }d}`, 2 401 406 + '3': `\${a${ `b${ `c${ JSON.stringify({ 0 406 406 | '4': {}, 0 406 401 | }) }d` }e` }f}`, 0 401 400 | }; 1 400 400 0 400 400 // Original request 0 400 400 fetchOptions.body = ` 0 400 400 { 0 400 400 "accountNumber" : "248796", 0 400 400 "customerType" : "Shipper", 0 400 400 "destinationCity" : "${order.destination.city}", 0 400 400 "destinationState" : "${order.destination.stateProvince}", 0 400 400 "destinationZip" : ${order.destination.postalCode}, 0 400 400 "paymentType" : "Prepaid", 0 400 400 "shipmentInfo" : 0 400 400 { 0 400 400 "items" : [ { "shipmentClass" : "50", "shipmentWeight" : "${order.totalWeight.toString()}" } ] 0 400 400 } 0 400 400 }`; 1 400 400 tmpok_q575y/lexilla/test/examples/cpp/94Template.cxx.styled0000664000175000017500000000254314773064066023545 0ustar gusnangusnan{2}// Test JavaScript template expressions for issue 94 {0} {2}// Basic {5}var{0} {11}basic{0} {10}={0} {20}`{10}${{11}identifier{10}}{20}`{10};{0} {2}// Nested {5}var{0} {11}nested{0} {10}={0} {20}` {10}${{0} {20}` {10}${{0} {4}1{0} {10}}{20} `{0} {10}}{20} `{10};{0} {2}// With escapes {5}var{0} {11}xxx{0} {10}={0} {10}{{0} {7}'1'{10}:{0} {20}`{27}\`\u0020\${20}{a{10}${{4}1{0} {10}+{0} {4}1{10}}{20}b}`{10},{0} {7}'2'{10}:{0} {20}`{27}\${20}{a{10}${{0} {20}`b{10}${{4}1{0} {10}+{0} {4}2{10}}{20}c`{10}.{16}charCodeAt{10}({4}2{10}){0} {10}}{20}d}`{10},{0} {7}'3'{10}:{0} {20}`{27}\${20}{a{10}${{0} {20}`b{10}${{0} {20}`c{10}${{0} {19}JSON{10}.{16}stringify{10}({{0} {7}'4'{10}:{0} {10}{},{0} {10}}){0} {10}}{20}d`{0} {10}}{20}e`{0} {10}}{20}f}`{10},{0} {10}};{0} {2}// Original request {11}fetchOptions{10}.{11}body{0} {10}={0} {20}` { "accountNumber" : "248796", "customerType" : "Shipper", "destinationCity" : "{10}${{11}order{10}.{11}destination{10}.{11}city{10}}{20}", "destinationState" : "{10}${{11}order{10}.{11}destination{10}.{11}stateProvince{10}}{20}", "destinationZip" : {10}${{11}order{10}.{11}destination{10}.{11}postalCode{10}}{20}, "paymentType" : "Prepaid", "shipmentInfo" : { "items" : [ { "shipmentClass" : "50", "shipmentWeight" : "{10}${{11}order{10}.{11}totalWeight{10}.{11}toString{10}()}{20}" } ] } }`{10};{0} tmpok_q575y/lexilla/test/examples/cpp/AllStyles.cxx.folded0000664000175000017500000001076214773064066023464 0ustar gusnangusnan 0 400 400 // Enumerate all primary styles: 0 to 27 and secondary styles 64 to 91 1 400 400 0 400 400 // default=0 1 400 400 1 400 400 0 400 400 // comment=1 0 400 400 /* */ 1 400 400 0 400 400 /* commentline=2 */ 0 400 400 // example line 1 400 400 0 400 400 // commentdoc=3 0 400 400 /** */ 1 400 400 0 400 400 // number=4 0 400 400 123 1 400 400 0 400 400 // word=5 0 400 400 int 1 400 400 0 400 400 // string=6 0 400 400 "string" 1 400 400 0 400 400 // character=7 0 400 400 'c' 1 400 400 0 400 400 // uuid=8 0 400 400 uuid(3fd43029-1354-42f0-a5be-4a484c9c5250) 1 400 400 0 400 400 // preprocessor=9 0 400 400 #define xxx 1 1 400 400 0 400 400 // operator=10 0 400 400 {} 1 400 400 0 400 400 // identifier=11 0 400 400 identifier 1 400 400 0 400 400 // stringeol=12 0 400 400 " 1 400 400 0 400 400 // verbatim=13 0 400 400 @"verbatim" 1 400 400 0 400 400 // regex=14 0 400 400 (/regex/) 1 400 400 0 400 400 // commentlinedoc=15 0 400 400 /// example 1 400 400 0 400 400 // word2=16 0 400 400 second 1 400 400 0 400 400 // commentdockeyword=17 0 400 400 /** @file */ 1 400 400 0 400 400 // commentdockeyworderror=18 0 400 400 /** @wrongkey */ 1 400 400 0 400 400 // globalclass=19 0 400 400 global 1 400 400 0 400 400 // stringraw=20 0 400 400 R"( )" 1 400 400 0 400 400 // tripleverbatim=21 0 400 400 """ xx """ 1 400 400 0 400 400 // hashquotedstring=22 0 400 400 #" xx " 1 400 400 0 400 400 // preprocessorcomment=23 0 400 400 #define /* comment */ 1 400 400 0 400 400 // preprocessorcommentdoc=24 0 400 400 #define /** comment */ 1 400 400 0 400 400 // userliteral=25 0 400 400 1_date_ 1 400 400 0 400 400 // taskmarker=26 0 400 400 /* TODO: sleep */ 1 400 400 0 400 400 // escapesequence=27 0 400 400 "\001 \b" 1 400 400 0 400 400 // identifier substyles.11.1=128 0 400 400 vector 1 400 400 0 400 400 // identifier substyles.11.2=129 0 400 400 std 1 400 400 0 400 400 // commentdockeyword substyles.17.1=130 0 400 400 /** @module */ 1 400 400 0 400 400 // Secondary styles inside preprocessor excluded section 1 400 400 2 400 401 + #if 0 1 401 401 | 0 401 401 | // default=0 1 401 401 | 1 401 401 | 0 401 401 | // comment=1 0 401 401 | /* */ 1 401 401 | 0 401 401 | /* commentline=2 */ 0 401 401 | // example line 1 401 401 | 0 401 401 | // commentdoc=3 0 401 401 | /** */ 1 401 401 | 0 401 401 | // number=4 0 401 401 | 123 1 401 401 | 0 401 401 | // word=5 0 401 401 | int 1 401 401 | 0 401 401 | // string=6 0 401 401 | "string" 1 401 401 | 0 401 401 | // character=7 0 401 401 | 'c' 1 401 401 | 0 401 401 | // uuid=8 0 401 401 | uuid(3fd43029-1354-42f0-a5be-4a484c9c5250) 1 401 401 | 0 401 401 | // preprocessor=9 0 401 401 | #define xxx 1 1 401 401 | 0 401 401 | // operator=10 0 401 401 | {} 1 401 401 | 0 401 401 | // identifier=11 0 401 401 | identifier 1 401 401 | 0 401 401 | // stringeol=12 0 401 401 | " 1 401 401 | 0 401 401 | // verbatim=13 0 401 401 | @"verbatim" 1 401 401 | 0 401 401 | // regex=14 0 401 401 | (/regex/) 1 401 401 | 0 401 401 | // commentlinedoc=15 0 401 401 | /// example 1 401 401 | 0 401 401 | // word2=16 0 401 401 | second 1 401 401 | 0 401 401 | // commentdockeyword=17 0 401 401 | /** @file */ 1 401 401 | 0 401 401 | // commentdockeyworderror=18 0 401 401 | /** @wrongkey */ 1 401 401 | 0 401 401 | // globalclass=19 0 401 401 | global 1 401 401 | 0 401 401 | // stringraw=20 0 401 401 | R"( )" 1 401 401 | 0 401 401 | // tripleverbatim=21 0 401 401 | """ xx """ 1 401 401 | 0 401 401 | // hashquotedstring=22 0 401 401 | #" xx " 1 401 401 | 0 401 401 | // preprocessorcomment=23 0 401 401 | #define /* comment */ 1 401 401 | 0 401 401 | // preprocessorcommentdoc=24 0 401 401 | #define /** comment */ 1 401 401 | 0 401 401 | // userliteral=25 0 401 401 | 1_date_ 1 401 401 | 0 401 401 | // taskmarker=26 0 401 401 | /* TODO: sleep */ 1 401 401 | 0 401 401 | // escapesequence=27 0 401 401 | "\001 \b" 1 401 401 | 0 401 401 | // identifier substyles.75.1=192 0 401 401 | vector 1 401 401 | 0 401 401 | // identifier substyles.75.2=193 0 401 401 | std 1 401 401 | 0 401 401 | // commentdockeyword substyles.81.1=194 0 401 401 | /** @module */ 1 401 401 | 0 401 400 | #endif 1 400 400 tmpok_q575y/lexilla/test/examples/cpp/130NonAsciiKeyword.cxx.styled0000664000175000017500000000030514773064066025103 0ustar gusnangusnan{2}// coding: utf-8 // All three following symbols should highlight as keywords {5}cheese{0} {5}käse{0} {5}ÑÑ‹Ñ€{0} {2}// Lookalikes with ASCII so should not highlight: {11}ÑÑ‹p{0} {11}cÑ‹p{0} tmpok_q575y/lexilla/test/examples/cpp/149KeywordCase.cxx.styled0000664000175000017500000000023714773064066024271 0ustar gusnangusnan{2}// SCE_C_WORD2 (16) {16}second{0} {2}// SCE_C_IDENTIFIER (11) {11}Second{0} {2}// SCE_C_IDENTIFIER (11) {11}upper{0} {2}// SCE_C_WORD2 (16) {16}Upper{0} tmpok_q575y/lexilla/test/examples/cpp/149KeywordCase.cxx0000664000175000017500000000016714773064066022770 0ustar gusnangusnan// SCE_C_WORD2 (16) second // SCE_C_IDENTIFIER (11) Second // SCE_C_IDENTIFIER (11) upper // SCE_C_WORD2 (16) Upper tmpok_q575y/lexilla/test/examples/cpp/x.cxx.styled0000664000175000017500000000417514773064066022067 0ustar gusnangusnan{2}#!/usr/bin/env node {0} {2}// A demonstration program {9}#include #if 0 {23}/* */{9} {73}#define DUMMY() \ if (1); {9}#endif {0} {2}// Test preprocessor expressions with parentheses {9}#if ((0)) {75}a{64} {9}#elif ((1)) {11}b{0} {9}#endif {0} {3}/** {17}@file{3} LexCPP.cxx <{17}file{3}> <{17}file{3} >filename LexCPP.cxx. **/{0} {3}/** Unknown doc keywords so in SCE_C_COMMENTDOCKEYWORDERROR: {18}@wrong{3} LexCPP.cxx <{18}wrong{3}>filename Next line should not start a keyword but before 5.4.1 did and caused bad styling or a crash depending on range lexed < **/{0} {9}#define M\ {0}\ {2}// Test preprocessor active branches feature {0} {9}#if HAVE_COLOUR {2}// Active {9}#endif #if NOT_HAVE_COLOUR {66}// Inactive {9}#endif {0} {9}#if FEATURE==2 {2}// Active {9}#endif #if FEATURE==3 {66}// Inactive {9}#endif {0} {9}#if VERSION(1,2)==3 {2}// Active {9}#endif #if VERSION(1,2)==4 {66}// Inactive {9}#endif {0} {9}#undef HAVE_COLOUR #if HAVE_COLOUR {66}// Inactive {9}#endif {0} {9}#define MULTIPLY(a,b) a*b #if MULTIPLY(2,3)==6 {2}// Active {9}#endif {0} {9}#define ONE 1 #if ONE != 1 {66}// Inactive {9}#endif {0} {5}int{0} {11}main{10}(){0} {10}{{0} {11}double{0} {11}x{10}[]{0} {10}={0} {10}{{4}3.14159{10},{4}6.02e23{10},{4}1.6e-19{10},{4}1.0{10}+{4}1{10}};{0} {5}int{0} {11}y{10}[]{0} {10}={0} {10}{{4}75{10},{4}0113{10},{4}0x4b{10}};{0} {11}printf{10}({6}"hello world %d %g{27}\n{6}"{10},{0} {11}y{10}[{4}0{10}],{0} {11}x{10}[{4}0{10}]);{0} {2}// JavaScript regular expression (14) tests {0} {5}let{0} {11}a{0} {10}={0} {14}/a/{10};{0} {5}let{0} {11}b{0} {10}={0} {14}/[a-z]+/gi{10};{0} {14}/a|b/i{10}.{11}test{10}({6}"baby"{10});{0} {2}// arrow function {0} {10}(){0} {10}=>{0} {14}/a|b/i{10}.{11}test{10}({6}"baby"{10});{0} {2}// Escape sequence (27) tests {0} {11}printf{10}({6}"{27}\'\"\?\\\a\b\f\n\r\t\v{6} {27}\P{6}"{10});{0} {11}printf{10}({6}"{27}\0{6}a {27}\013{6}a {27}\01{6}9"{10});{0} {11}printf{10}({6}"{27}\x013a{6}c {27}\xd{6}z"{10});{0} {11}printf{10}({6}"{27}\ua34d{6}f {27}\u{6}z"{10});{0} {11}printf{10}({6}"{27}\Ua34df783{6}3 {27}\U{6}z"{10});{0} {10}}{0} tmpok_q575y/lexilla/test/examples/cpp/Bug2245.cxx.styled0000664000175000017500000000033114773064066022640 0ustar gusnangusnan{5}int{0} {11}i{10};{0} {9}#if 1 {11}i{10}={4}1{10};{0} {9}# {11}i{10}={4}2{10};{0} {9}#else {75}i{74}={68}3{74};{64} {9}#endif {11}i{10}={4}4{10};{0} {9}#elif 1 {11}i{10}={4}5{10};{0} {9}#else {11}i{10}={4}6{10};{0} tmpok_q575y/lexilla/test/examples/cpp/AllStyles.cxx.styled0000664000175000017500000000555414773064066023536 0ustar gusnangusnan{2}// Enumerate all primary styles: 0 to 27 and secondary styles 64 to 91 {0} {2}// default=0 {0} {2}// comment=1 {1}/* */{0} {1}/* commentline=2 */{0} {2}// example line {0} {2}// commentdoc=3 {3}/** */{0} {2}// number=4 {4}123{0} {2}// word=5 {5}int{0} {2}// string=6 {6}"string"{0} {2}// character=7 {7}'c'{0} {2}// uuid=8 {5}uuid{10}({8}3fd43029-1354-42f0-a5be-4a484c9c5250{10}){0} {2}// preprocessor=9 {9}#define xxx 1 {0} {2}// operator=10 {10}{}{0} {2}// identifier=11 {11}identifier{0} {2}// stringeol=12 {12}" {0} {2}// verbatim=13 {13}@"verbatim"{0} {2}// regex=14 {10}({14}/regex/{10}){0} {2}// commentlinedoc=15 {15}/// example {0} {2}// word2=16 {16}second{0} {2}// commentdockeyword=17 {3}/** {17}@file{3} */{0} {2}// commentdockeyworderror=18 {3}/** {18}@wrongkey{3} */{0} {2}// globalclass=19 {19}global{0} {2}// stringraw=20 {20}R"( )"{0} {2}// tripleverbatim=21 {21}""" xx """{0} {2}// hashquotedstring=22 {22}#" xx "{0} {2}// preprocessorcomment=23 {9}#define {23}/* comment */{9} {0} {2}// preprocessorcommentdoc=24 {9}#define {24}/** comment */{9} {0} {2}// userliteral=25 {25}1_date_{0} {2}// taskmarker=26 {1}/* {26}TODO{1}: sleep */{0} {2}// escapesequence=27 {6}"{27}\001{6} {27}\b{6}"{0} {2}// identifier substyles.11.1=128 {128}vector{0} {2}// identifier substyles.11.2=129 {129}std{0} {2}// commentdockeyword substyles.17.1=130 {3}/** {130}@module{3} */{0} {2}// Secondary styles inside preprocessor excluded section {0} {9}#if 0 {64} {66}// default=0 {64} {66}// comment=1 {65}/* */{64} {65}/* commentline=2 */{64} {66}// example line {64} {66}// commentdoc=3 {67}/** */{64} {66}// number=4 {68}123{64} {66}// word=5 {69}int{64} {66}// string=6 {70}"string"{64} {66}// character=7 {71}'c'{64} {66}// uuid=8 {69}uuid{74}({72}3fd43029-1354-42f0-a5be-4a484c9c5250{74}){64} {66}// preprocessor=9 {73}#define xxx 1 {64} {66}// operator=10 {74}{}{64} {66}// identifier=11 {75}identifier{64} {66}// stringeol=12 {76}" {64} {66}// verbatim=13 {77}@"verbatim"{64} {66}// regex=14 {74}({78}/regex/{74}){64} {66}// commentlinedoc=15 {79}/// example {64} {66}// word2=16 {80}second{64} {66}// commentdockeyword=17 {67}/** {81}@file{67} */{64} {66}// commentdockeyworderror=18 {67}/** {82}@wrongkey{67} */{64} {66}// globalclass=19 {83}global{64} {66}// stringraw=20 {84}R"( )"{64} {66}// tripleverbatim=21 {85}""" xx """{64} {66}// hashquotedstring=22 {86}#" xx "{64} {66}// preprocessorcomment=23 {73}#define {87}/* comment */{73} {64} {66}// preprocessorcommentdoc=24 {73}#define {88}/** comment */{73} {64} {66}// userliteral=25 {89}1_date_{64} {66}// taskmarker=26 {65}/* {90}TODO{65}: sleep */{64} {66}// escapesequence=27 {70}"{91}\001{70} {91}\b{70}"{64} {66}// identifier substyles.75.1=192 {192}vector{64} {66}// identifier substyles.75.2=193 {193}std{64} {66}// commentdockeyword substyles.81.1=194 {67}/** {194}@module{67} */{64} {9}#endif tmpok_q575y/lexilla/test/examples/cpp/149KeywordCase.cxx.folded0000664000175000017500000000042314773064066024217 0ustar gusnangusnan 0 400 400 // SCE_C_WORD2 (16) 0 400 400 second 1 400 400 0 400 400 // SCE_C_IDENTIFIER (11) 0 400 400 Second 1 400 400 0 400 400 // SCE_C_IDENTIFIER (11) 0 400 400 upper 1 400 400 0 400 400 // SCE_C_WORD2 (16) 0 400 400 Upper 1 400 400 tmpok_q575y/lexilla/test/examples/cpp/x.cxx0000664000175000017500000000260714773064066020562 0ustar gusnangusnan#!/usr/bin/env node // A demonstration program #include #if 0 /* */ #define DUMMY() \ if (1); #endif // Test preprocessor expressions with parentheses #if ((0)) a #elif ((1)) b #endif /** @file LexCPP.cxx filename LexCPP.cxx. **/ /** Unknown doc keywords so in SCE_C_COMMENTDOCKEYWORDERROR: @wrong LexCPP.cxx filename Next line should not start a keyword but before 5.4.1 did and caused bad styling or a crash depending on range lexed < **/ #define M\ \ // Test preprocessor active branches feature #if HAVE_COLOUR // Active #endif #if NOT_HAVE_COLOUR // Inactive #endif #if FEATURE==2 // Active #endif #if FEATURE==3 // Inactive #endif #if VERSION(1,2)==3 // Active #endif #if VERSION(1,2)==4 // Inactive #endif #undef HAVE_COLOUR #if HAVE_COLOUR // Inactive #endif #define MULTIPLY(a,b) a*b #if MULTIPLY(2,3)==6 // Active #endif #define ONE 1 #if ONE != 1 // Inactive #endif int main() { double x[] = {3.14159,6.02e23,1.6e-19,1.0+1}; int y[] = {75,0113,0x4b}; printf("hello world %d %g\n", y[0], x[0]); // JavaScript regular expression (14) tests let a = /a/; let b = /[a-z]+/gi; /a|b/i.test("baby"); // arrow function () => /a|b/i.test("baby"); // Escape sequence (27) tests printf("\'\"\?\\\a\b\f\n\r\t\v \P"); printf("\0a \013a \019"); printf("\x013ac \xdz"); printf("\ua34df \uz"); printf("\Ua34df7833 \Uz"); } tmpok_q575y/lexilla/test/examples/cpp/130NonAsciiKeyword.cxx0000664000175000017500000000023714773064066023604 0ustar gusnangusnan// coding: utf-8 // All three following symbols should highlight as keywords cheese käse ÑÑ‹Ñ€ // Lookalikes with ASCII so should not highlight: ÑÑ‹p cÑ‹p tmpok_q575y/lexilla/test/examples/cpp/x.cxx.folded0000664000175000017500000000510014773064066022005 0ustar gusnangusnan 0 400 400 #!/usr/bin/env node 1 400 400 0 400 400 // A demonstration program 0 400 400 #include 2 400 401 + #if 0 /* */ 0 401 401 | #define DUMMY() \ 0 401 401 | if (1); 0 401 400 | #endif 1 400 400 0 400 400 // Test preprocessor expressions with parentheses 2 400 401 + #if ((0)) 0 401 401 | a 0 401 401 | #elif ((1)) 0 401 401 | b 0 401 400 | #endif 1 400 400 2 400 401 + /** @file LexCPP.cxx 0 401 401 | 0 401 401 | filename 0 401 401 | LexCPP.cxx. 0 401 401 | 0 401 400 | **/ 1 400 400 2 400 401 + /** Unknown doc keywords so in SCE_C_COMMENTDOCKEYWORDERROR: 0 401 401 | @wrong LexCPP.cxx 0 401 401 | filename 0 401 401 | Next line should not start a keyword but before 5.4.1 did and caused bad styling or a crash depending on range lexed 0 401 401 | < 0 401 400 | **/ 1 400 400 0 400 400 #define M\ 1 400 400 0 400 400 \ 1 400 400 1 400 400 0 400 400 // Test preprocessor active branches feature 1 400 400 2 400 401 + #if HAVE_COLOUR 0 401 401 | // Active 0 401 400 | #endif 2 400 401 + #if NOT_HAVE_COLOUR 0 401 401 | // Inactive 0 401 400 | #endif 1 400 400 2 400 401 + #if FEATURE==2 0 401 401 | // Active 0 401 400 | #endif 2 400 401 + #if FEATURE==3 0 401 401 | // Inactive 0 401 400 | #endif 1 400 400 2 400 401 + #if VERSION(1,2)==3 0 401 401 | // Active 0 401 400 | #endif 2 400 401 + #if VERSION(1,2)==4 0 401 401 | // Inactive 0 401 400 | #endif 1 400 400 0 400 400 #undef HAVE_COLOUR 2 400 401 + #if HAVE_COLOUR 0 401 401 | // Inactive 0 401 400 | #endif 1 400 400 0 400 400 #define MULTIPLY(a,b) a*b 2 400 401 + #if MULTIPLY(2,3)==6 0 401 401 | // Active 0 401 400 | #endif 1 400 400 0 400 400 #define ONE 1 2 400 401 + #if ONE != 1 0 401 401 | // Inactive 0 401 400 | #endif 1 400 400 2 400 401 + int main() { 0 401 401 | double x[] = {3.14159,6.02e23,1.6e-19,1.0+1}; 0 401 401 | int y[] = {75,0113,0x4b}; 0 401 401 | printf("hello world %d %g\n", y[0], x[0]); 1 401 401 | 0 401 401 | // JavaScript regular expression (14) tests 0 401 401 | let a = /a/; 0 401 401 | let b = /[a-z]+/gi; 0 401 401 | /a|b/i.test("baby"); 0 401 401 | // arrow function 0 401 401 | () => /a|b/i.test("baby"); 1 401 401 | 0 401 401 | // Escape sequence (27) tests 0 401 401 | printf("\'\"\?\\\a\b\f\n\r\t\v \P"); 0 401 401 | printf("\0a \013a \019"); 0 401 401 | printf("\x013ac \xdz"); 0 401 401 | printf("\ua34df \uz"); 0 401 401 | printf("\Ua34df7833 \Uz"); 0 401 400 | } 1 400 400 tmpok_q575y/lexilla/test/examples/python/0000775000175000017500000000000014773064066020321 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/python/f-strings.py.styled0000664000175000017500000000052614773064066024115 0ustar gusnangusnan{1}# Simple nesting{0} {16}f" {{0} {3}""{0} {16}} "{0} {1}# Multi-line field with comment{0} {16}f" {{0} {3}""{0} {1}# comment{0} {16}} "{0} {1}# Single quoted continued with \{0} {16}f" \ "{0} {1}# 4 nested f-strings{0} {17}f'Outer {{16}f"nested {{2}1{16}} {f"nested {{2}2{16}} {f"nested {{2}3{16}} {f"nested {{2}4{16}}"}"}"}"{17}}'{0} tmpok_q575y/lexilla/test/examples/python/strings.py0000664000175000017500000000030614773064066022363 0ustar gusnangusnan# Simple raw string r'' # Raw f-string rf'' fr'' # Raw byte string rb'' br'' # Raw unicode strings: ur'' is valid in 2.7 (but not in 3) -- always lexed as # valid; ru'' is never valid ru'' ur'' tmpok_q575y/lexilla/test/examples/python/x.py0000664000175000017500000000051514773064066021143 0ustar gusnangusnan# Convert all punctuation characters except '_', '*', and '.' into spaces. def depunctuate(s): '''A docstring''' """Docstring 2""" d = "" for ch in s: if ch in 'abcde': d = d + ch else: d = d + " " return d import contextlib @contextlib.contextmanager def singleuse(): print("Before") yield with singleuse(): pass tmpok_q575y/lexilla/test/examples/python/x.py.styled0000664000175000017500000000117414773064066022450 0ustar gusnangusnan{1}# Convert all punctuation characters except '_', '*', and '.' into spaces.{0} {5}def{0} {9}depunctuate{10}({11}s{10}):{0} {6}'''A docstring'''{0} {7}"""Docstring 2"""{0} {11}d{0} {10}={0} {3}""{0} {5}for{0} {11}ch{0} {5}in{0} {11}s{10}:{0} {5}if{0} {11}ch{0} {5}in{0} {4}'abcde'{10}:{0} {11}d{0} {10}={0} {11}d{0} {10}+{0} {11}ch{0} {5}else{10}:{0} {11}d{0} {10}={0} {11}d{0} {10}+{0} {3}" "{0} {5}return{0} {11}d{0} {5}import{0} {11}contextlib{0} {15}@contextlib{10}.{11}contextmanager{0} {5}def{0} {9}singleuse{10}():{0} {5}print{10}({3}"Before"{10}){0} {5}yield{0} {5}with{0} {11}singleuse{10}():{0} {5}pass{0} tmpok_q575y/lexilla/test/examples/python/SciTE.properties0000664000175000017500000000023314773064066023404 0ustar gusnangusnanlexer.*.py=python keywords.*.py=case class def else for if import in match pass print return while with yield keywords2.*.py=hilight fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/python/AllStyles.py.styled0000664000175000017500000000207614773064066024117 0ustar gusnangusnan{1}# Enumerate all styles: 0 to 19{0} {1}# comment=1{0} {1}# whitespace=0{0} {1}# w{0} {1}# number=2{0} {2}37{0} {1}# double-quoted-string=3{0} {3}"str"{0} {1}# single-quoted-string=4{0} {4}'str'{0} {1}# keyword=5{0} {5}pass{0} {1}# triple-quoted-string=6{0} {6}'''str'''{0} {1}# triple-double-quoted-string=7{0} {7}"""str"""{0} {1}# class-name=8{0} {5}class{0} {8}ClassName{10}:{0} {5}pass{0} {1}# function-name=9{0} {5}def{0} {9}function_name{10}():{0} {5}pass{0} {1}# operator=10{0} {2}1{0} {10}+{0} {2}3{0} {1}# identifier=11{0} {11}identifier{0} {10}={0} {2}2{0} {1}# comment-block=12{0} {12}## block{0} {1}# unclosed-string=13{0} {13}" unclosed {0} {1}# highlighted-identifier=14{0} {14}hilight{0} {10}={0} {2}2{0} {1}# decorator=15{0} {15}@staticmethod{0} {5}def{0} {9}fn{10}():{0} {5}pass{0} {11}a{0} {10}={0} {2}1{0} {1}# double-quoted-f-string=16{0} {16}f"{{11}a{16}}"{0} {1}# single-quoted-f-string=17{0} {17}f'{{11}a{17}}'{0} {1}# triple-quoted-f-string=18{0} {18}f'''{{11}a{18}}'''{0} {1}# double-triple-quoted-f-string=19{0} {19}f"""{{11}a{19}}"""{0} tmpok_q575y/lexilla/test/examples/python/matchcase.py0000664000175000017500000000066614773064066022633 0ustar gusnangusnan# Match and case as keywords match (x): case +1: pass case -1: pass case []: pass # Match and case as identifiers match = 1 def match(): pass match.group() 1 + match case.attribute # Unfortunately wrong classifications; should be rare in real code because # non-call expressions usually don't begin lines, the exceptions are match(x) # and case(x) match(x) case(x) match + 1 case + 1 case[1] tmpok_q575y/lexilla/test/examples/python/f-strings.py.folded0000664000175000017500000000067314773064066024051 0ustar gusnangusnan 0 400 0 # Simple nesting 0 400 0 f" { "" } " 1 400 0 0 400 0 # Multi-line field with comment 0 400 0 f" { 1 400 0 0 400 0 "" # comment 1 400 0 0 400 0 } " 1 400 0 0 400 0 # Single quoted continued with \ 0 400 0 f" \ 0 400 0 " 1 400 0 0 400 0 # 4 nested f-strings 0 400 0 f'Outer {f"nested {1} {f"nested {2} {f"nested {3} {f"nested {4}"}"}"}"}' 1 400 0 tmpok_q575y/lexilla/test/examples/python/AllStyles.py.folded0000664000175000017500000000276414773064066024054 0ustar gusnangusnan 0 400 0 # Enumerate all styles: 0 to 19 0 400 0 # comment=1 1 400 0 0 400 0 # whitespace=0 0 400 0 # w 1 400 0 0 400 0 # number=2 0 400 0 37 1 400 0 0 400 0 # double-quoted-string=3 0 400 0 "str" 1 400 0 0 400 0 # single-quoted-string=4 0 400 0 'str' 1 400 0 0 400 0 # keyword=5 0 400 0 pass 1 400 0 0 400 0 # triple-quoted-string=6 0 400 0 '''str''' 1 400 0 0 400 0 # triple-double-quoted-string=7 0 400 0 """str""" 1 400 0 0 400 0 # class-name=8 2 400 0 + class ClassName: 0 408 0 | pass 1 400 0 0 400 0 # function-name=9 2 400 0 + def function_name(): 0 408 0 | pass 1 400 0 0 400 0 # operator=10 0 400 0 1 + 3 1 400 0 0 400 0 # identifier=11 0 400 0 identifier = 2 1 400 0 0 400 0 # comment-block=12 0 400 0 ## block 1 400 0 0 400 0 # unclosed-string=13 0 400 0 " unclosed 1 400 0 0 400 0 # highlighted-identifier=14 0 400 0 hilight = 2 1 400 0 0 400 0 # decorator=15 0 400 0 @staticmethod 0 400 0 def fn(): pass 1 400 0 0 400 0 a = 1 0 400 0 # double-quoted-f-string=16 0 400 0 f"{a}" 1 400 0 0 400 0 # single-quoted-f-string=17 0 400 0 f'{a}' 1 400 0 0 400 0 # triple-quoted-f-string=18 0 400 0 f'''{a}''' 1 400 0 0 400 0 # double-triple-quoted-f-string=19 0 400 0 f"""{a}""" 1 400 0 tmpok_q575y/lexilla/test/examples/python/f-strings.py0000664000175000017500000000033614773064066022611 0ustar gusnangusnan# Simple nesting f" { "" } " # Multi-line field with comment f" { "" # comment } " # Single quoted continued with \ f" \ " # 4 nested f-strings f'Outer {f"nested {1} {f"nested {2} {f"nested {3} {f"nested {4}"}"}"}"}' tmpok_q575y/lexilla/test/examples/python/x.py.folded0000664000175000017500000000112114773064066022371 0ustar gusnangusnan 0 400 0 # Convert all punctuation characters except '_', '*', and '.' into spaces. 2 400 0 + def depunctuate(s): 0 408 0 | '''A docstring''' 0 408 0 | """Docstring 2""" 0 408 0 | d = "" 2 408 0 + for ch in s: 2 410 0 + if ch in 'abcde': 0 418 0 | d = d + ch 2 410 0 + else: 0 418 0 | d = d + " " 0 408 0 | return d 1 400 0 0 400 0 import contextlib 1 400 0 0 400 0 @contextlib.contextmanager 2 400 0 + def singleuse(): 0 408 0 | print("Before") 0 408 0 | yield 0 400 0 with singleuse(): pass 1 400 0 tmpok_q575y/lexilla/test/examples/python/strings.py.folded0000664000175000017500000000064314773064066023623 0ustar gusnangusnan 0 400 0 # Simple raw string 0 400 0 r'' 1 400 0 0 400 0 # Raw f-string 0 400 0 rf'' 0 400 0 fr'' 1 400 0 0 400 0 # Raw byte string 0 400 0 rb'' 0 400 0 br'' 1 400 0 0 400 0 # Raw unicode strings: ur'' is valid in 2.7 (but not in 3) -- always lexed as 0 400 0 # valid; ru'' is never valid 0 400 0 ru'' 0 400 0 ur'' 1 400 0 1 400 0 tmpok_q575y/lexilla/test/examples/python/AllStyles.py0000664000175000017500000000126414773064066022612 0ustar gusnangusnan# Enumerate all styles: 0 to 19 # comment=1 # whitespace=0 # w # number=2 37 # double-quoted-string=3 "str" # single-quoted-string=4 'str' # keyword=5 pass # triple-quoted-string=6 '''str''' # triple-double-quoted-string=7 """str""" # class-name=8 class ClassName: pass # function-name=9 def function_name(): pass # operator=10 1 + 3 # identifier=11 identifier = 2 # comment-block=12 ## block # unclosed-string=13 " unclosed # highlighted-identifier=14 hilight = 2 # decorator=15 @staticmethod def fn(): pass a = 1 # double-quoted-f-string=16 f"{a}" # single-quoted-f-string=17 f'{a}' # triple-quoted-f-string=18 f'''{a}''' # double-triple-quoted-f-string=19 f"""{a}""" tmpok_q575y/lexilla/test/examples/python/matchcase.py.styled0000664000175000017500000000135314773064066024130 0ustar gusnangusnan{1}# Match and case as keywords{0} {5}match{0} {10}({11}x{10}):{0} {5}case{0} {10}+{2}1{10}:{0} {5}pass{0} {5}case{0} {10}-{2}1{10}:{0} {5}pass{0} {5}case{0} {10}[]:{0} {5}pass{0} {1}# Match and case as identifiers{0} {11}match{0} {10}={0} {2}1{0} {5}def{0} {9}match{10}():{0} {5}pass{0} {11}match{10}.{11}group{10}(){0} {2}1{0} {10}+{0} {11}match{0} {11}case{10}.{11}attribute{0} {1}# Unfortunately wrong classifications; should be rare in real code because{0} {1}# non-call expressions usually don't begin lines, the exceptions are match(x){0} {1}# and case(x){0} {5}match{10}({11}x{10}){0} {5}case{10}({11}x{10}){0} {5}match{0} {10}+{0} {2}1{0} {5}case{0} {10}+{0} {2}1{0} {5}case{10}[{2}1{10}]{0} tmpok_q575y/lexilla/test/examples/python/strings.py.styled0000664000175000017500000000042414773064066023667 0ustar gusnangusnan{1}# Simple raw string{0} {4}r''{0} {1}# Raw f-string{0} {17}rf''{0} {17}fr''{0} {1}# Raw byte string{0} {4}rb''{0} {4}br''{0} {1}# Raw unicode strings: ur'' is valid in 2.7 (but not in 3) -- always lexed as{0} {1}# valid; ru'' is never valid{0} {11}ru{4}''{0} {4}ur''{0} tmpok_q575y/lexilla/test/examples/python/attributes/0000775000175000017500000000000014773064066022507 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/python/attributes/attrib-id.py.folded0000664000175000017500000000140414773064066026173 0ustar gusnangusnan 0 400 0 varname = 1 0 400 0 # identifier in first line was mis-styled as attribute when bug existed 1 400 0 0 400 0 # left comment ends with period. this was okay before bug. 0 400 0 varname = 2 1 400 0 0 400 0 x = 1 # comment after code ends with period. this failed when bug existed. 0 400 0 varname = 3 1 400 0 2 400 0 + def dummy(): 0 404 0 | # indented comment ends with period.this failed when bug existed. 0 404 0 | varname = 4 1 400 0 0 400 0 x = 2 ## comment block is the same. 0 400 0 varname = 5 1 400 0 0 400 0 # per issue#294, identifiers were mis-styled as attributes when at beginning of file 0 400 0 # and when after a non-left-justifed comment 1 400 0 tmpok_q575y/lexilla/test/examples/python/attributes/attrib-decorator.py.folded0000664000175000017500000000054614773064066027567 0ustar gusnangusnan 0 400 0 # issue#294 also pointed out that decorator attributes behaved differently 0 400 0 # for left-justified decorators vs indented decorators 1 400 0 0 400 0 @decorator.attribute 2 400 0 + def foo(): 0 404 0 | @decorator.attribute 2 404 0 + def bar(): 0 408 0 | pass 0 404 0 | bar() 1 404 0 | tmpok_q575y/lexilla/test/examples/python/attributes/attributes.py0000664000175000017500000000055614773064066025255 0ustar gusnangusnan# attributes=20 s = "thing thing".findall("thing") a.very.complicated.expression.findall("test") # fake out. b.very.complicated.expression. findall("test2") c.very.complicated.expression. \ findall("test3") d.very.complicated.expression.\ findall("test4") @staticmethod.attrtest @staticmethod. attrtest @staticmethod. \ attrtest @staticmethod.\ attrtest tmpok_q575y/lexilla/test/examples/python/attributes/attributes.py.styled0000664000175000017500000000126714773064066026560 0ustar gusnangusnan{1}# attributes=20{0} {11}s{0} {10}={0} {3}"thing thing"{10}.{20}findall{10}({3}"thing"{10}){0} {11}a{10}.{20}very{10}.{20}complicated{10}.{20}expression{10}.{20}findall{10}({3}"test"{10}){0} {1}# fake out.{0} {11}b{10}.{20}very{10}.{20}complicated{10}.{20}expression{10}.{0} {20}findall{10}({3}"test2"{10}){0} {11}c{10}.{20}very{10}.{20}complicated{10}.{20}expression{10}.{0} \ {20}findall{10}({3}"test3"{10}){0} {11}d{10}.{20}very{10}.{20}complicated{10}.{20}expression{10}.{0}\ {20}findall{10}({3}"test4"{10}){0} {15}@staticmethod{10}.{15}attrtest{0} {15}@staticmethod{10}.{0} {15}attrtest{0} {15}@staticmethod{10}.{0} \ {15}attrtest{0} {15}@staticmethod{10}.{0}\ {15}attrtest{0} tmpok_q575y/lexilla/test/examples/python/attributes/SciTE.properties0000664000175000017500000000052314773064066025574 0ustar gusnangusnanlexer.*.py=python keywords.*.py=class def else for if import in pass print return while with yield keywords2.*.py=hilight fold=1 fold.compact=1 lexer.python.identifier.attributes=1 lexer.python.decorator.attributes=1 substyles.python.11=3 substylewords.11.3.$(file.patterns.py)=findall replace style.python.11.3=fore:#EEAA80,italics,bold tmpok_q575y/lexilla/test/examples/python/attributes/attrib-id.py0000664000175000017500000000101514773064066024735 0ustar gusnangusnanvarname = 1 # identifier in first line was mis-styled as attribute when bug existed # left comment ends with period. this was okay before bug. varname = 2 x = 1 # comment after code ends with period. this failed when bug existed. varname = 3 def dummy(): # indented comment ends with period.this failed when bug existed. varname = 4 x = 2 ## comment block is the same. varname = 5 # per issue#294, identifiers were mis-styled as attributes when at beginning of file # and when after a non-left-justifed comment tmpok_q575y/lexilla/test/examples/python/attributes/attrib-decorator.py.styled0000664000175000017500000000047714773064066027641 0ustar gusnangusnan{1}# issue#294 also pointed out that decorator attributes behaved differently{0} {1}# for left-justified decorators vs indented decorators{0} {15}@decorator{10}.{15}attribute{0} {5}def{0} {9}foo{10}():{0} {15}@decorator{10}.{15}attribute{0} {5}def{0} {9}bar{10}():{0} {5}pass{0} {11}bar{10}(){0} tmpok_q575y/lexilla/test/examples/python/attributes/attrib-id.py.styled0000664000175000017500000000132414773064066026243 0ustar gusnangusnan{11}varname{0} {10}={0} {2}1{0} {1}# identifier in first line was mis-styled as attribute when bug existed{0} {1}# left comment ends with period. this was okay before bug.{0} {11}varname{0} {10}={0} {2}2{0} {11}x{0} {10}={0} {2}1{0} {1}# comment after code ends with period. this failed when bug existed.{0} {11}varname{0} {10}={0} {2}3{0} {5}def{0} {9}dummy{10}():{0} {1}# indented comment ends with period.this failed when bug existed.{0} {11}varname{0} {10}={0} {2}4{0} {11}x{0} {10}={0} {2}2{0} {12}## comment block is the same.{0} {11}varname{0} {10}={0} {2}5{0} {1}# per issue#294, identifiers were mis-styled as attributes when at beginning of file{0} {1}# and when after a non-left-justifed comment{0} tmpok_q575y/lexilla/test/examples/python/attributes/attrib-decorator.py0000664000175000017500000000034414773064066026327 0ustar gusnangusnan# issue#294 also pointed out that decorator attributes behaved differently # for left-justified decorators vs indented decorators @decorator.attribute def foo(): @decorator.attribute def bar(): pass bar() tmpok_q575y/lexilla/test/examples/python/attributes/attributes.py.folded0000664000175000017500000000113014773064066026476 0ustar gusnangusnan 0 400 0 # attributes=20 0 400 0 s = "thing thing".findall("thing") 0 400 0 a.very.complicated.expression.findall("test") 0 400 0 # fake out. 2 400 0 + b.very.complicated.expression. 0 404 0 | findall("test2") 2 400 0 + c.very.complicated.expression. \ 0 404 0 | findall("test3") 2 400 0 + d.very.complicated.expression.\ 0 404 0 | findall("test4") 0 400 0 @staticmethod.attrtest 0 400 0 @staticmethod. 0 400 0 attrtest 0 400 0 @staticmethod. \ 0 400 0 attrtest 0 400 0 @staticmethod.\ 0 400 0 attrtest 1 400 0 tmpok_q575y/lexilla/test/examples/python/matchcase.py.folded0000664000175000017500000000141014773064066024053 0ustar gusnangusnan 0 400 0 # Match and case as keywords 2 400 0 + match (x): 2 404 0 + case +1: 0 408 0 | pass 2 404 0 + case -1: 0 408 0 | pass 2 404 0 + case []: 0 408 0 | pass 1 408 0 | 0 400 0 # Match and case as identifiers 0 400 0 match = 1 2 400 0 + def match(): 0 404 0 | pass 0 400 0 match.group() 0 400 0 1 + match 0 400 0 case.attribute 1 400 0 0 400 0 # Unfortunately wrong classifications; should be rare in real code because 0 400 0 # non-call expressions usually don't begin lines, the exceptions are match(x) 0 400 0 # and case(x) 0 400 0 match(x) 0 400 0 case(x) 0 400 0 match + 1 0 400 0 case + 1 0 400 0 case[1] 1 400 0 tmpok_q575y/lexilla/test/examples/fortran/0000775000175000017500000000000014773064066020453 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/fortran/AllStyles.f0000664000175000017500000000072414773064066022541 0ustar gusnangusnan! Enumerate all styles: 0 to 14 ! This is not a viable source file, it just illustrates the different states in isolation. ! comment=1 ! Comment ! default=0 ! w ! number=2 .37 ! string1=3 'string' ! string2=4 "string" ! stringeol=5 " unclosed ! operator=6 + ! identifier=7 variable ! word=8 program ! word2=9 system_clock ! word3=10 doublecomplex ! preprocessor=11 !DEC$ ATTRIBUTES DLLEXPORT::sr1 ! operator2=12 .lt. ! label=13 999 ! continuation=14 & tmpok_q575y/lexilla/test/examples/fortran/AllStyles.f.folded0000664000175000017500000000210414773064066023767 0ustar gusnangusnan 0 400 0 ! Enumerate all styles: 0 to 14 0 400 0 ! This is not a viable source file, it just illustrates the different states in isolation. 1 400 0 0 400 0 ! comment=1 0 400 0 ! Comment 1 400 0 0 400 0 ! default=0 0 400 0 ! w 1 400 0 0 400 0 ! number=2 0 400 0 .37 1 400 0 0 400 0 ! string1=3 0 400 0 'string' 1 400 0 0 400 0 ! string2=4 0 400 0 "string" 1 400 0 0 400 0 ! stringeol=5 0 400 0 " unclosed 1 400 0 0 400 0 ! operator=6 0 400 0 + 1 400 0 0 400 0 ! identifier=7 0 400 0 variable 1 400 0 0 400 0 ! word=8 2 400 0 + program 1 401 0 | 0 401 0 | ! word2=9 0 401 0 | system_clock 1 401 0 | 0 401 0 | ! word3=10 0 401 0 | doublecomplex 1 401 0 | 0 401 0 | ! preprocessor=11 0 401 0 | !DEC$ ATTRIBUTES DLLEXPORT::sr1 1 401 0 | 0 401 0 | ! operator2=12 0 401 0 | .lt. 1 401 0 | 0 401 0 | ! label=13 0 401 0 | 999 1 401 0 | 0 401 0 | ! continuation=14 0 401 0 | & 0 400 0 tmpok_q575y/lexilla/test/examples/fortran/SciTE.properties0000664000175000017500000000017614773064066023544 0ustar gusnangusnanlexer.*.f=fortran keywords.*.f=do end if program keywords2.*.f=system_clock keywords3.*.f=doublecomplex fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/fortran/AllStyles.f.styled0000664000175000017500000000123114773064066024036 0ustar gusnangusnan{1}! Enumerate all styles: 0 to 14{0} {1}! This is not a viable source file, it just illustrates the different states in isolation.{0} {1}! comment=1{0} {1}! Comment{0} {1}! default=0{0} {1}! w{0} {1}! number=2{0} {2}.37{0} {1}! string1=3{0} {3}'string'{0} {1}! string2=4{0} {4}"string"{0} {1}! stringeol=5{0} {5}" unclosed {0} {1}! operator=6{0} {6}+{0} {1}! identifier=7{0} {7}variable{0} {1}! word=8{0} {8}program{0} {1}! word2=9{0} {9}system_clock{0} {1}! word3=10{0} {10}doublecomplex{0} {1}! preprocessor=11{0} {11}!DEC$ ATTRIBUTES DLLEXPORT::sr1{0} {1}! operator2=12{0} {12}.lt.{0} {1}! label=13{0} {13}999{0} {1}! continuation=14{0} {14}&{0} tmpok_q575y/lexilla/test/examples/r/0000775000175000017500000000000014773064066017241 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/r/102Backticks.r.styled0000664000175000017500000000046614773064066023056 0ustar gusnangusnan{1}# ugly code to demonstrate multiline string.{0} {12}`Hello World`{0} {8}<-{0} {9}function{8}({9}x{0}, {9}y{0}, {9}z{8}){0} {8}{{0} {9}print{8}({9}x{8}){0}; {9}print{8}({9}y{8}){0}; {9}print{8}({9}z{8}){0}; {8}}{0} {12}`Hello\nWorld`{8}({6}"Hello\nMoon!"{0}, {6}"Hello Venus"{0}, {7}'Hello\ Mars'{8}){0}; tmpok_q575y/lexilla/test/examples/r/102Backticks.r0000664000175000017500000000026314773064066021546 0ustar gusnangusnan# ugly code to demonstrate multiline string. `Hello World` <- function(x, y, z) { print(x); print(y); print(z); } `Hello\nWorld`("Hello\nMoon!", "Hello Venus", 'Hello\ Mars'); tmpok_q575y/lexilla/test/examples/r/SciTE.properties0000664000175000017500000000021414773064066022323 0ustar gusnangusnanlexer.*.r=r keywords.*.r=if keywords2.*.r=abbreviate keywords3.*.r=acme fold=1 fold.compact=1 match AllStyles.r lexer.r.escape.sequence=1 tmpok_q575y/lexilla/test/examples/r/AllStyles.r.styled0000664000175000017500000000257614773064066022655 0ustar gusnangusnan{1}# https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Reserved-words{0} {2}if{0} {1}# base keyword (3){0} {3}abbreviate{0} {1}# other keyword (4){0} {4}acme{0} {1}# infix operator{0} {1}# https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Special-operators{0} {10}%x%{0} {1}# https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Literal-constants{0} {1}# Valid integer constants{0} {5}1L{0}, {5}0x10L{0}, {5}1000000L{0}, {5}1e6L{0} {1}# Valid numeric constants{0} {5}1{0} {5}10{0} {5}0.1{0} {5}.2{0} {5}1e-7{0} {5}1.2e+7{0} {5}1.1L{0}, {5}1e-3L{0}, {5}0x1.1p-2{0} {1}# Valid complex constants{0} {5}2i{0} {5}4.1i{0} {5}1e-2i{0} {1}# https://search.r-project.org/R/refmans/base/html/Quotes.html{0} {1}# single quotes{0} {7}'"It{15}\'{7}s alive!", he screamed.'{0} {1}# double quotes{0} {6}"{15}\"{6}It's alive!{15}\"{6}, he screamed."{0} {1}# escape sequence{0} {6}"{15}\n{6}0{15}\r{6}1{15}\t{6}2{15}\b{6}3{15}\a{6}4{15}\f{6}5{15}\\{6}6{15}\'{6}7{15}\"{6}8{15}\`{6}9"{0} {6}"{15}\123{6}0{15}\x12{6}1{15}\u1234{6}2{15}\U00012345{6}3{15}\u{1234}{6}4{15}\U{00012345}{6}5{15}\{6} 6{15}\ {6}7"{0} {1}# issue #206{0} {6}"{15}\n{6}"{0} {6}"{15}\r\n{6}"{0} {1}# Backticks{0} {9}d{8}${12}`1st column`{0} {1}# double quoted raw string{0} {13}r"---(\1--)-)---"{0} {1}# single quoted raw string{0} {14}R'---(\1--)-)---'{0} {1}# infix EOL (11){0} {11}%a {1}#back to comment{0} tmpok_q575y/lexilla/test/examples/r/AllStyles.r.folded0000664000175000017500000000312314773064066022573 0ustar gusnangusnan 0 400 400 # https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Reserved-words 0 400 400 if 1 400 400 0 400 400 # base keyword (3) 0 400 400 abbreviate 1 400 400 0 400 400 # other keyword (4) 0 400 400 acme 1 400 400 0 400 400 # infix operator 0 400 400 # https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Special-operators 0 400 400 %x% 1 400 400 0 400 400 # https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Literal-constants 0 400 400 # Valid integer constants 0 400 400 1L, 0x10L, 1000000L, 1e6L 1 400 400 0 400 400 # Valid numeric constants 0 400 400 1 10 0.1 .2 1e-7 1.2e+7 0 400 400 1.1L, 1e-3L, 0x1.1p-2 1 400 400 0 400 400 # Valid complex constants 0 400 400 2i 4.1i 1e-2i 1 400 400 0 400 400 # https://search.r-project.org/R/refmans/base/html/Quotes.html 0 400 400 # single quotes 0 400 400 '"It\'s alive!", he screamed.' 1 400 400 0 400 400 # double quotes 0 400 400 "\"It's alive!\", he screamed." 1 400 400 0 400 400 # escape sequence 0 400 400 "\n0\r1\t2\b3\a4\f5\\6\'7\"8\`9" 0 400 400 "\1230\x121\u12342\U000123453\u{1234}4\U{00012345}5\ 0 400 400 6\ 7" 0 400 400 # issue #206 0 400 400 "\n" 0 400 400 "\r\n" 1 400 400 0 400 400 # Backticks 0 400 400 d$`1st column` 1 400 400 0 400 400 # double quoted raw string 0 400 400 r"---(\1--)-)---" 1 400 400 0 400 400 # single quoted raw string 0 400 400 R'---(\1--)-)---' 1 400 400 0 400 400 # infix EOL (11) 0 400 400 %a 0 400 400 #back to comment 0 400 0 tmpok_q575y/lexilla/test/examples/r/102Backticks.r.folded0000664000175000017500000000050214773064066022776 0ustar gusnangusnan 0 400 400 # ugly code to demonstrate multiline string. 0 400 400 `Hello 2 400 401 + World` <- function(x, y, z) { 0 401 401 | print(x); 0 401 401 | print(y); 0 401 401 | print(z); 0 401 400 | } 0 400 400 `Hello\nWorld`("Hello\nMoon!", "Hello 0 400 400 Venus", 'Hello\ 0 400 400 Mars'); 0 400 0 tmpok_q575y/lexilla/test/examples/r/AllStyles.r0000664000175000017500000000165714773064066021351 0ustar gusnangusnan# https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Reserved-words if # base keyword (3) abbreviate # other keyword (4) acme # infix operator # https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Special-operators %x% # https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Literal-constants # Valid integer constants 1L, 0x10L, 1000000L, 1e6L # Valid numeric constants 1 10 0.1 .2 1e-7 1.2e+7 1.1L, 1e-3L, 0x1.1p-2 # Valid complex constants 2i 4.1i 1e-2i # https://search.r-project.org/R/refmans/base/html/Quotes.html # single quotes '"It\'s alive!", he screamed.' # double quotes "\"It's alive!\", he screamed." # escape sequence "\n0\r1\t2\b3\a4\f5\\6\'7\"8\`9" "\1230\x121\u12342\U000123453\u{1234}4\U{00012345}5\ 6\ 7" # issue #206 "\n" "\r\n" # Backticks d$`1st column` # double quoted raw string r"---(\1--)-)---" # single quoted raw string R'---(\1--)-)---' # infix EOL (11) %a #back to comment tmpok_q575y/lexilla/test/examples/smalltalk/0000775000175000017500000000000014773064066020764 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/smalltalk/ClassificationTable.st.styled0000664000175000017500000000554014773064066026546 0ustar gusnangusnan{3}" File contains examples of all SCE_ST_* lexical states 0-16 "{0} {3}" Smalltalk code from the lexer that generates the character classification table."{0} {5}|{0} lexTable classificationBlock charClasses {5}|{0} charClasses {14}:={0} {12}#({4}#DecDigit{0} {4}#Letter{0} {4}#Special{0} {4}#Upper{0} {4}#BinSel{12}).{0} lexTable {14}:={0} {10}ByteArray{0} {13}new:{0} {2}128{12}.{0} classificationBlock {14}:={0} {12}[{0} {12}:{0}charClass {12}:{0}chars {5}|{0} {5}|{0} flag {5}|{0} flag {14}:={0} {2}1{0} {13}bitShift:{0} {12}({0}charClasses {13}indexOf:{0} charClass{12}){0} {5}-{0} {2}1{12}.{0} chars {13}do:{0} {12}[{0} {12}:{0}char {5}|{0} lexTable {13}at:{0} char codePoint {5}+{0} {2}1{0} {13}put:{0} {12}(({0}lexTable {13}at:{0} char codePoint {5}+{0} {2}1{12}){0} {13}bitOr:{0} flag{12})]].{0} classificationBlock {13}value:{0} {4}#DecDigit{0} {13}value:{0} {1}'0123456789'{12};{0} {13}value:{0} {4}#Letter{0} {13}value:{0} {1}'_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'{12};{0} {13}value:{0} {4}#Special{0} {13}value:{0} {1}'()[]{};.^:'{12};{0} {13}value:{0} {4}#BinSel{0} {13}value:{0} {1}'~@%&*-+=|\/,<>?!'{12};{0} {13}value:{0} {4}#Upper{0} {13}value:{0} {1}'ABCDEFGHIJKLMNOPQRSTUVWXYZ'{12}.{0} {12}(({10}String{0} {13}new:{0} {2}500{12}){0} {13}streamContents:{0} {12}[{0} {12}:{0}stream {5}|{0} stream crLf{12};{0} {13}nextPutAll:{0} {1}'static int ClassificationTable[256] = {'{12}.{0} lexTable {13}keysAndValuesDo:{0} {12}[{0} {12}:{0}index {12}:{0}value {5}|{0} {12}(({0}index {5}-{0} {2}1{12}){0} {13}rem:{0} {2}16{12}){0} {5}=={0} {2}0{0} {16}ifTrue:{0} {12}[{0} stream crLf{12};{0} tab{12}]{0} {16}ifFalse:{0} {12}[{0} stream space{12}].{0} stream {13}print:{0} value{12}.{0} index {5}~={0} {2}256{0} {16}ifTrue:{0} {12}[{0} stream {13}nextPut:{0} {15}$,{12}]].{0} stream crLf{12};{0} {13}nextPutAll:{0} {1}'};'{12};{0} crLf{12}.{0} charClasses {13}keysAndValuesDo:{0} {12}[{0} {12}:{0}index {12}:{0}name {5}|{0} stream crLf{12};{0} {13}nextPutAll:{0} {12}({0} {12}({1}'static inline bool is<1s>(unsigned char ch) {return (ch %< 0x80) && ((ClassificationTable[ch] & <2p>) != 0);}'{12}){0} {13}expandMacrosWith:{0} name {13}with:{0} {12}({2}1{0} {13}bitShift:{0} {12}({0}index {5}-{0} {2}1{12}))){0} {12}]]){0} edit {3}" Some more syntax examples: ^ is return (SCE_ST_RETURN) true or false is bool (SCE_ST_BOOL) self (SCE_ST_SELF) super (SCE_ST_SUPER) nil (SCE_ST_NIL) "{0} foo {11}^{0} {10}Array{0} {13}with:{0} {2}1{0} {13}with:{0} {2}2{0} {13}with:{0} {6}false{0} {13}with:{0} {7}self{0} {13}with:{0} {8}super{0} {13}with:{0} {9}nil{12}.{0} {3}" Issue 274: A decimal separator is not required for scaled decimal numbers"{0} {2}32.0s2{0} {2}4.0e3{0} {2}32s2{0} {2}4e3{0} tmpok_q575y/lexilla/test/examples/smalltalk/SciTE.properties0000664000175000017500000000020514773064066024046 0ustar gusnangusnanlexer.*.st=smalltalk keywords.*.st=ifTrue: ifFalse: whileTrue: whileFalse: ifNil: ifNotNil: whileTrue whileFalse repeat isNil notNil tmpok_q575y/lexilla/test/examples/smalltalk/ClassificationTable.st.folded0000664000175000017500000000503214773064066026473 0ustar gusnangusnan 0 400 0 " File contains examples of all SCE_ST_* lexical states 0-16 " 0 400 0 " Smalltalk code from the lexer that generates the character classification table." 0 400 0 | lexTable classificationBlock charClasses | 0 400 0 charClasses := #(#DecDigit #Letter #Special #Upper #BinSel). 0 400 0 lexTable := ByteArray new: 128. 0 400 0 classificationBlock := [ :charClass :chars | 0 400 0 | flag | 0 400 0 flag := 1 bitShift: (charClasses indexOf: charClass) - 1. 0 400 0 chars do: [ :char | lexTable at: char codePoint + 1 put: ((lexTable at: char codePoint + 1) bitOr: flag)]]. 0 400 0 0 400 0 classificationBlock 0 400 0 value: #DecDigit value: '0123456789'; 0 400 0 value: #Letter value: '_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'; 0 400 0 value: #Special value: '()[]{};.^:'; 0 400 0 value: #BinSel value: '~@%&*-+=|\/,<>?!'; 0 400 0 value: #Upper value: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. 0 400 0 0 400 0 ((String new: 500) streamContents: [ :stream | 0 400 0 stream crLf; nextPutAll: 'static int ClassificationTable[256] = {'. 0 400 0 lexTable keysAndValuesDo: [ :index :value | 0 400 0 ((index - 1) rem: 16) == 0 ifTrue: [ 0 400 0 stream crLf; tab] 0 400 0 ifFalse: [ 0 400 0 stream space]. 0 400 0 stream print: value. 0 400 0 index ~= 256 ifTrue: [ 0 400 0 stream nextPut: $,]]. 0 400 0 stream crLf; nextPutAll: '};'; crLf. 0 400 0 0 400 0 charClasses keysAndValuesDo: [ :index :name | 0 400 0 stream 0 400 0 crLf; 0 400 0 nextPutAll: ( 0 400 0 ('static inline bool is<1s>(unsigned char ch) {return (ch %< 0x80) && ((ClassificationTable[ch] & <2p>) != 0);}') 0 400 0 expandMacrosWith: name with: (1 bitShift: (index - 1))) 0 400 0 ]]) edit 0 400 0 0 400 0 " Some more syntax examples: 0 400 0 ^ is return (SCE_ST_RETURN) 0 400 0 true or false is bool (SCE_ST_BOOL) 0 400 0 self (SCE_ST_SELF) 0 400 0 super (SCE_ST_SUPER) 0 400 0 nil (SCE_ST_NIL) 0 400 0 " 0 400 0 foo 0 400 0 ^ Array with: 1 with: 2 with: false with: self with: super with: nil. 0 400 0 0 400 0 " Issue 274: A decimal separator is not required for scaled decimal numbers" 0 400 0 32.0s2 0 400 0 4.0e3 0 400 0 32s2 0 400 0 4e3 0 400 0 tmpok_q575y/lexilla/test/examples/smalltalk/ClassificationTable.st0000664000175000017500000000355114773064066025243 0ustar gusnangusnan" File contains examples of all SCE_ST_* lexical states 0-16 " " Smalltalk code from the lexer that generates the character classification table." | lexTable classificationBlock charClasses | charClasses := #(#DecDigit #Letter #Special #Upper #BinSel). lexTable := ByteArray new: 128. classificationBlock := [ :charClass :chars | | flag | flag := 1 bitShift: (charClasses indexOf: charClass) - 1. chars do: [ :char | lexTable at: char codePoint + 1 put: ((lexTable at: char codePoint + 1) bitOr: flag)]]. classificationBlock value: #DecDigit value: '0123456789'; value: #Letter value: '_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'; value: #Special value: '()[]{};.^:'; value: #BinSel value: '~@%&*-+=|\/,<>?!'; value: #Upper value: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. ((String new: 500) streamContents: [ :stream | stream crLf; nextPutAll: 'static int ClassificationTable[256] = {'. lexTable keysAndValuesDo: [ :index :value | ((index - 1) rem: 16) == 0 ifTrue: [ stream crLf; tab] ifFalse: [ stream space]. stream print: value. index ~= 256 ifTrue: [ stream nextPut: $,]]. stream crLf; nextPutAll: '};'; crLf. charClasses keysAndValuesDo: [ :index :name | stream crLf; nextPutAll: ( ('static inline bool is<1s>(unsigned char ch) {return (ch %< 0x80) && ((ClassificationTable[ch] & <2p>) != 0);}') expandMacrosWith: name with: (1 bitShift: (index - 1))) ]]) edit " Some more syntax examples: ^ is return (SCE_ST_RETURN) true or false is bool (SCE_ST_BOOL) self (SCE_ST_SELF) super (SCE_ST_SUPER) nil (SCE_ST_NIL) " foo ^ Array with: 1 with: 2 with: false with: self with: super with: nil. " Issue 274: A decimal separator is not required for scaled decimal numbers" 32.0s2 4.0e3 32s2 4e3 tmpok_q575y/lexilla/test/examples/mmixal/0000775000175000017500000000000014773064066020267 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/mmixal/x.mms.folded0000664000175000017500000000060314773064066022507 0ustar gusnangusnan 0 400 0 % Some example code 0 400 0 0 400 0 % Set the address of the program initially to 0x100. 0 400 0 LOC #100 0 400 0 0 400 0 Main GETA $255,string 0 400 0 0 400 0 TRAP 0,Fputs,StdOut 0 400 0 0 400 0 TRAP 0,Halt,0 0 400 0 0 400 0 string BYTE "Hello, world!",#a,0 0 400 0 tmpok_q575y/lexilla/test/examples/mmixal/references.mms.styled0000664000175000017500000000131114773064066024425 0ustar gusnangusnan{1}# Bug #2019 Buffer over-read in MMIXAL lexer {2}label{4} {0} {5}PREFIX{7} {10}Foo:{1} % Relative reference (uses PREFIX) {0} {5}JMP{7} {10}label{1} % {0} {5}JMP{7} {10}@label{1} % Absolute reference (does not use PREFIX) {0} {5}JMP{7} {10}:label{1} % In register list so treated as register {0} {5}JMP{7} {13}:rA{1} % Too long for buffer so truncated {0} {5}JMP{7} {10}l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890{1} % Too long for buffer so truncated then treated as absolute {0} {5}JMP{7} {10}:l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890{1} % tmpok_q575y/lexilla/test/examples/mmixal/SciTE.properties0000664000175000017500000000016014773064066023351 0ustar gusnangusnanlexer.*.mms=mmixal keywords.*.mms=BYTE GETA JMP LOC PREFIX TRAP keywords2.*.mms=rA keywords3.*.mms=Fputs StdOut tmpok_q575y/lexilla/test/examples/mmixal/references.mms.folded0000664000175000017500000000145514773064066024367 0ustar gusnangusnan 0 400 0 # Bug #2019 Buffer over-read in MMIXAL lexer 0 400 0 label 0 400 0 PREFIX Foo: 0 400 0 % Relative reference (uses PREFIX) 0 400 0 JMP label 0 400 0 % 0 400 0 JMP @label 0 400 0 % Absolute reference (does not use PREFIX) 0 400 0 JMP :label 0 400 0 % In register list so treated as register 0 400 0 JMP :rA 0 400 0 % Too long for buffer so truncated 0 400 0 JMP l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 0 400 0 % Too long for buffer so truncated then treated as absolute 0 400 0 JMP :l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 0 400 0 % 0 400 0 tmpok_q575y/lexilla/test/examples/mmixal/AllStyles.mms.styled0000664000175000017500000000205714773064066024230 0ustar gusnangusnan{1}% Demonstrate each possible style. Does not make sense as code. {0} {1}% A comment 1 % Comment {0} {1}% Whitespace 0 {0} {1}% Label 2 {2}label{4} {0} {1}% Not Validated Opcode 3 appears to always validate to either 5 or 6 % so is never seen on screen. {0} {1}% Division between Label and Opcode 4 {2}la{4} {0} {1}% Valid Opcode 5 {0} {5}TRAP{7} {0} {1}% Invalid Opcode 6 {0} {6}UNKNOWN{7} {0} {1}% Division between Opcode and Operands 7 {0} {5}LOC{7} {0} {1}% Division of Operands 8 {0} {5}LOC{7} {9}0{8}.{1} {0} {1}% Number 9 {0} {5}BYTE{7} {9}0{1} {0} {1}% Reference 10 {0} {5}JMP{7} {10}@label{1} {0} {1}% Char 11 {0} {5}BYTE{7} {11}'a'{1} {0} {1}% String 12 {0} {5}BYTE{7} {12}"Hello, world!"{1} {0} {1}% Register 13 {0} {5}BYTE{7} {13}rA{1} {0} {1}% Hexadecimal Number 14 {0} {5}BYTE{7} {14}#FF{1} {0} {1}% Operator 15 {0} {5}BYTE{7} {15}+{1} {0} {1}% Symbol 16 {0} {5}TRAP{7} {16}Fputs{1} {0} {1}% Preprocessor 17 {17}@include a.mms {0} tmpok_q575y/lexilla/test/examples/mmixal/x.mms0000664000175000017500000000033214773064066021252 0ustar gusnangusnan% Some example code % Set the address of the program initially to 0x100. LOC #100 Main GETA $255,string TRAP 0,Fputs,StdOut TRAP 0,Halt,0 string BYTE "Hello, world!",#a,0 tmpok_q575y/lexilla/test/examples/mmixal/x.mms.styled0000664000175000017500000000056314773064066022563 0ustar gusnangusnan{1}% Some example code {0} {1}% Set the address of the program initially to 0x100. {0} {5}LOC{7} {14}#100{1} {0} {2}Main{4} {5}GETA{7} {13}$255{15},{10}string{1} {0} {5}TRAP{7} {9}0{15},{16}Fputs{15},{16}StdOut{1} {0} {5}TRAP{7} {9}0{15},{10}Halt{15},{9}0{1} {0} {2}string{4} {5}BYTE{7} {12}"Hello, world!"{15},{14}#a{15},{9}0{1} tmpok_q575y/lexilla/test/examples/mmixal/AllStyles.mms.folded0000664000175000017500000000332014773064066024153 0ustar gusnangusnan 0 400 0 % Demonstrate each possible style. Does not make sense as code. 0 400 0 0 400 0 % A comment 1 0 400 0 % Comment 0 400 0 0 400 0 0 400 0 % Whitespace 0 0 400 0 0 400 0 0 400 0 0 400 0 % Label 2 0 400 0 label 0 400 0 0 400 0 0 400 0 % Not Validated Opcode 3 appears to always validate to either 5 or 6 0 400 0 % so is never seen on screen. 0 400 0 0 400 0 0 400 0 % Division between Label and Opcode 4 0 400 0 la 0 400 0 0 400 0 0 400 0 % Valid Opcode 5 0 400 0 TRAP 0 400 0 0 400 0 0 400 0 % Invalid Opcode 6 0 400 0 UNKNOWN 0 400 0 0 400 0 0 400 0 % Division between Opcode and Operands 7 0 400 0 LOC 0 400 0 0 400 0 0 400 0 % Division of Operands 8 0 400 0 LOC 0. 0 400 0 0 400 0 0 400 0 % Number 9 0 400 0 BYTE 0 0 400 0 0 400 0 0 400 0 % Reference 10 0 400 0 JMP @label 0 400 0 0 400 0 0 400 0 % Char 11 0 400 0 BYTE 'a' 0 400 0 0 400 0 0 400 0 % String 12 0 400 0 BYTE "Hello, world!" 0 400 0 0 400 0 0 400 0 % Register 13 0 400 0 BYTE rA 0 400 0 0 400 0 0 400 0 % Hexadecimal Number 14 0 400 0 BYTE #FF 0 400 0 0 400 0 0 400 0 % Operator 15 0 400 0 BYTE + 0 400 0 0 400 0 0 400 0 % Symbol 16 0 400 0 TRAP Fputs 0 400 0 0 400 0 0 400 0 % Preprocessor 17 0 400 0 @include a.mms 0 400 0 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/mmixal/AllStyles.mms0000664000175000017500000000140114773064066022715 0ustar gusnangusnan% Demonstrate each possible style. Does not make sense as code. % A comment 1 % Comment % Whitespace 0 % Label 2 label % Not Validated Opcode 3 appears to always validate to either 5 or 6 % so is never seen on screen. % Division between Label and Opcode 4 la % Valid Opcode 5 TRAP % Invalid Opcode 6 UNKNOWN % Division between Opcode and Operands 7 LOC % Division of Operands 8 LOC 0. % Number 9 BYTE 0 % Reference 10 JMP @label % Char 11 BYTE 'a' % String 12 BYTE "Hello, world!" % Register 13 BYTE rA % Hexadecimal Number 14 BYTE #FF % Operator 15 BYTE + % Symbol 16 TRAP Fputs % Preprocessor 17 @include a.mms tmpok_q575y/lexilla/test/examples/mmixal/references.mms0000664000175000017500000000112014773064066023120 0ustar gusnangusnan# Bug #2019 Buffer over-read in MMIXAL lexer label PREFIX Foo: % Relative reference (uses PREFIX) JMP label % JMP @label % Absolute reference (does not use PREFIX) JMP :label % In register list so treated as register JMP :rA % Too long for buffer so truncated JMP l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 % Too long for buffer so truncated then treated as absolute JMP :l1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 % tmpok_q575y/lexilla/test/examples/inno/0000775000175000017500000000000014773064066017743 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/inno/x.iss0000664000175000017500000000132314773064066020731 0ustar gusnangusnan#define app_copyright "Copyright 1999, app corporation" ; comment [Setup] AppName=MyApp AppCopyright={#app_copyright} WizardSmallImageFile=WizardSmallImageFile.bmp OnlyBelowVersion=6.01 [Files] Source: "app.exe"; DestDir: "{tmp}"; OnlyBelowVersion: 6.01 [INI] Key: "keyname1"; String: "unterminated Key: 'keyname2'; String: 'unterminated [Registry] Root: HKLM; ValueType: string [CustomMessages] keyname =Other tasks:'not string [Messages] keyname="{#app_copyright}"not string [Code] // comment (* comment *) { comment } { *) comment } (* } comment *) (* comment *) { comment } function ShouldInstallComCtlUpdate: Boolean; begin Result := False; Log('string'); IsEscaped('''good''', ''bad'); end; tmpok_q575y/lexilla/test/examples/inno/SciTE.properties0000664000175000017500000000073714773064066023037 0ustar gusnangusnanlexer.*.iss=inno fold=1 keywords.*.iss=code custommessages files ini messages registry setup keywords2.*.iss=appname appcopyright onlybelowversion wizardsmallimagefile keywords3.*.iss=destdir key onlybelowversion root source string valuetype keywords4.*.iss=define keywords5.*.iss=\ and begin break case const continue do downto else end except exit \ false finally for function if not of on or procedure repeat then to \ true try type until uses var while with keywords6.*.iss= tmpok_q575y/lexilla/test/examples/inno/x.iss.folded0000664000175000017500000000255214773064066022172 0ustar gusnangusnan 0 400 0 #define app_copyright "Copyright 1999, app corporation" 0 400 0 0 400 0 ; comment 0 400 0 2 400 0 + [Setup] 0 401 0 | AppName=MyApp 0 401 0 | AppCopyright={#app_copyright} 0 401 0 | WizardSmallImageFile=WizardSmallImageFile.bmp 0 401 0 | OnlyBelowVersion=6.01 0 401 0 | 2 400 0 + [Files] 0 401 0 | Source: "app.exe"; DestDir: "{tmp}"; OnlyBelowVersion: 6.01 0 401 0 | 2 400 0 + [INI] 0 401 0 | Key: "keyname1"; String: "unterminated 0 401 0 | Key: 'keyname2'; String: 'unterminated 0 401 0 | 2 400 0 + [Registry] 0 401 0 | Root: HKLM; ValueType: string 0 401 0 | 2 400 0 + [CustomMessages] 0 401 0 | keyname =Other tasks:'not string 0 401 0 | 2 400 0 + [Messages] 0 401 0 | keyname="{#app_copyright}"not string 0 401 0 | 2 400 0 + [Code] 0 401 0 | 0 401 0 | // comment 0 401 0 | 0 401 0 | (* comment *) 0 401 0 | 0 401 0 | { comment } 0 401 0 | 0 401 0 | { *) comment } 0 401 0 | 0 401 0 | (* } comment *) 0 401 0 | 0 401 0 | (* 0 401 0 | comment *) 0 401 0 | 0 401 0 | { 0 401 0 | comment } 0 401 0 | 0 401 0 | function ShouldInstallComCtlUpdate: Boolean; 0 401 0 | begin 0 401 0 | Result := False; 0 401 0 | Log('string'); 0 401 0 | IsEscaped('''good''', ''bad'); 0 401 0 | end; 0 400 0 tmpok_q575y/lexilla/test/examples/inno/x.iss.styled0000664000175000017500000000176214773064066022243 0ustar gusnangusnan{5}#define{0} app_copyright {10}"Copyright 1999, app corporation"{0} {1}; comment{0} {4}[Setup]{0} {2}AppName{0}=MyApp {2}AppCopyright{0}={6}{#app_copyright}{0} {2}WizardSmallImageFile{0}=WizardSmallImageFile.bmp {2}OnlyBelowVersion{0}=6.01 {4}[Files]{0} {3}Source{0}: {10}"app.exe"{0}; {3}DestDir{0}: {10}"{tmp}"{0}; {3}OnlyBelowVersion{0}: 6.01 {4}[INI]{0} {3}Key{0}: {10}"keyname1"{0}; {3}String{0}: {10}"unterminated{0} {3}Key{0}: {11}'keyname2'{0}; {3}String{0}: {11}'unterminated{0} {4}[Registry]{0} {3}Root{0}: HKLM; {3}ValueType{0}: string {4}[CustomMessages]{0} keyname =Other tasks:'not string {4}[Messages]{0} keyname="{6}{#app_copyright}{0}"not string {4}[Code]{0} {7}// comment{0} {7}(* comment *){0} {7}{ comment }{0} {7}{ *) comment }{0} {7}(* } comment *){0} {7}(* comment *){0} {7}{ comment }{0} {8}function{0} ShouldInstallComCtlUpdate: Boolean; {8}begin{0} Result := {8}False{0}; Log({11}'string'{0}); IsEscaped({11}'''good'''{0}, {11}''{0}bad{11}');{0} {8}end{0}; tmpok_q575y/lexilla/test/examples/batch/0000775000175000017500000000000014773064066020061 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/batch/Issue115.bat.styled0000664000175000017500000000172414773064066023377 0ustar gusnangusnan{1}rem remark and comment bug {0} {5}findstr{0} /c:"rem this" "file" {5}findstr{0} /c:":: this" "file" {1}:: SingleQuoted command string {2}for{0} /f {6}%%A{2} in{0} ('rem this'){2} do echo{0} {6}%%A{0} {1}:: DoubleQuoted string {2}for{0} /f {6}%%A{2} in{0} ("rem this"){2} do echo{0} {6}%%A{0} {1}:: BackQuote command string {2}for{0} /f "usebackq" {6}%%A{2} in{0} (`rem this`){2} do echo{0} {6}%%A{0} {1}:: Test the handling of quotes ' and " and escape ^ :: Comment {0} {1}:: With quotes {0}":: Text ""{1}:: Comment {0}':: Text ''{1}:: Comment :: Mixing quotes - likely incorrect as lexer tries ' and " separately, leaving an active quote {0}"'":: Text {1}:: With escapes {5}^::{0} Text {5}^{0}"{1}:: Comment {5}^{0}"":: Text {5}^{0}"""{1}:: Comment {5}^^{0}":: Text {5}^^{0}""{1}:: Comment {5}^^{0}""":: Text {1}:: With preceding command {5}mkdir{0} archive ":: Text {5}mkdir{0} archive ""{1}:: Comment {5}mkdir{0} archive ^"{1}:: Comment {5}mkdir{0} archive ^"":: Text tmpok_q575y/lexilla/test/examples/batch/x.bat.styled0000664000175000017500000000332214773064066022323 0ustar gusnangusnan{1}rem comment=1 rem 'echo' is word=2, 'a' is default=0 {2}echo{0} a {1}rem label=3 {3}:START {1}rem '@' is hide=4 {4}@{2}echo{0} b {1}rem 'gcc' is external command=5 {5}gcc{0} --version {1}rem '%PATH%' is variable=6 {2}echo{0} {6}%PATH%{0} {2}echo{0} {6}%ProgramFiles(x86)%{0} {1}rem operator=7 '=' {4}@{2}set{0} Q{7}={0}A {1}::comment=1 {0} {1}:: Bug 1624: this construct produced inconsistent brackets in the past {2}if ERRORLEVEL{0} 2{2} goto{0} END {4}@{2}if exist{0} a ( {2}echo{0} exists ){2} else{0} ( {2}echo{0} not ) {2}FOR{0} /L {6}%%G{2} IN{0} (2,1,4){2} DO{0} ({2}echo{0} {6}%%G{0}) {1}:: Bug 1997: keywords not recognized when preceded by '(' {2}IF NOT DEFINED{0} var ({2}SET{0} var{7}={0}1) {1}:: Bug 2065: keywords not recognized when followed by ')' {4}@{2}if exist{0} a ({2} exit{0}) {1}:: Bug: with \r or \n, 'command' is seen as continuation {2}echo{0} word ^ 1 {5}command{0} {1}:: Bug argument and variable expansion {2}echo{0} {6}%~dp0{0}123 {2}echo{0} {6}%%-{0}~012 {2}echo{0} %%~{6}%%~-abcd{0} {2}FOR{0} /F {6}%%I{2} in{0} ("C:\Test\temp.txt"){2} do echo{0} {6}%%~dI{0} {1}:: Bug ending of argument and variable expansion {2}echo{0} {6}%~dp0{0}\123 {2}echo{0} "{6}%~dp0{0}123" {2}echo{0} "{6}%%-{0}~012" {2}echo{0} "%%~{6}%%~-abcd{0}" {2}FOR{0} /F {6}%%I{2} in{0} ("C:\Test\temp.txt"){2} do echo{0} "{6}%%~dI{0}" {1}:: Bug escaped % {2}echo{0} {6}%%0{0} {2}echo{0} %%{6}%0{0} {2}echo{0} %%{6}%%~-abcd{0} {3}:TEST{8} that after label style works {1}:: Bug 2304: "::" comments not recognised when second command on line {2}Set{0} /A xxx{7}={6}%xxx%{7}+{0}1 {7}&{0} {1}:: Increment {2}Set{0} /A xxx{7}={6}%xxx%{7}+{0}1 {7}&{0} {1}::Increment {2}Set{0} /A xxx{7}={6}%xxx%{7}+{0}1 {7}&{0} {1}rem Increment {0} {3}:END tmpok_q575y/lexilla/test/examples/batch/Issue115.bat.folded0000664000175000017500000000240114773064066023321 0ustar gusnangusnan 0 400 0 rem remark and comment bug 0 400 0 0 400 0 findstr /c:"rem this" "file" 0 400 0 findstr /c:":: this" "file" 0 400 0 0 400 0 :: SingleQuoted command string 0 400 0 for /f %%A in ('rem this') do echo %%A 0 400 0 0 400 0 :: DoubleQuoted string 0 400 0 for /f %%A in ("rem this") do echo %%A 0 400 0 0 400 0 :: BackQuote command string 0 400 0 for /f "usebackq" %%A in (`rem this`) do echo %%A 0 400 0 0 400 0 :: Test the handling of quotes ' and " and escape ^ 0 400 0 :: Comment 0 400 0 0 400 0 :: With quotes 0 400 0 ":: Text 0 400 0 "":: Comment 0 400 0 ':: Text 0 400 0 '':: Comment 0 400 0 :: Mixing quotes - likely incorrect as lexer tries ' and " separately, leaving an active quote 0 400 0 "'":: Text 0 400 0 0 400 0 :: With escapes 0 400 0 ^:: Text 0 400 0 ^":: Comment 0 400 0 ^"":: Text 0 400 0 ^""":: Comment 0 400 0 ^^":: Text 0 400 0 ^^"":: Comment 0 400 0 ^^""":: Text 0 400 0 0 400 0 :: With preceding command 0 400 0 mkdir archive ":: Text 0 400 0 mkdir archive "":: Comment 0 400 0 mkdir archive ^":: Comment 0 400 0 mkdir archive ^"":: Text 0 400 0 tmpok_q575y/lexilla/test/examples/batch/Issue222.bat.styled0000664000175000017500000000071614773064066023376 0ustar gusnangusnan{1}rem Keywords with colon {0} {1}rem with spacing {2}call{5} file.bat{0} arg1 {2}call{0} "file.bat" arg1 {2}call{0} :label arg1 {2}goto{0} :label {2}goto{0} :eof {2}goto{0} label {2}echo{0}: {6}%var%{0} {2}echo{0}: text {2}echo{0} text {1}rem no spacing {2}call{0}:label arg1 {2}goto{0}:label {2}goto{0}:eof {2}echo{0}:{6}%var%{0} {2}echo{0}:text ({2}call{0}) ({2}echo{0}:) ({2}goto{0}) {1}rem call internal commands {2}call echo{0} text {2}call set{0} "a=b" tmpok_q575y/lexilla/test/examples/batch/SciTE.properties0000664000175000017500000000015114773064066023143 0ustar gusnangusnanlexer.*.bat=batch keywords.*.bat=call defined do echo else errorlevel exist exit for goto if in not set tmpok_q575y/lexilla/test/examples/batch/Issue115.bat0000664000175000017500000000137114773064066022072 0ustar gusnangusnanrem remark and comment bug findstr /c:"rem this" "file" findstr /c:":: this" "file" :: SingleQuoted command string for /f %%A in ('rem this') do echo %%A :: DoubleQuoted string for /f %%A in ("rem this") do echo %%A :: BackQuote command string for /f "usebackq" %%A in (`rem this`) do echo %%A :: Test the handling of quotes ' and " and escape ^ :: Comment :: With quotes ":: Text "":: Comment ':: Text '':: Comment :: Mixing quotes - likely incorrect as lexer tries ' and " separately, leaving an active quote "'":: Text :: With escapes ^:: Text ^":: Comment ^"":: Text ^""":: Comment ^^":: Text ^^"":: Comment ^^""":: Text :: With preceding command mkdir archive ":: Text mkdir archive "":: Comment mkdir archive ^":: Comment mkdir archive ^"":: Text tmpok_q575y/lexilla/test/examples/batch/x.bat0000664000175000017500000000234314773064066021022 0ustar gusnangusnanrem comment=1 rem 'echo' is word=2, 'a' is default=0 echo a rem label=3 :START rem '@' is hide=4 @echo b rem 'gcc' is external command=5 gcc --version rem '%PATH%' is variable=6 echo %PATH% echo %ProgramFiles(x86)% rem operator=7 '=' @set Q=A ::comment=1 :: Bug 1624: this construct produced inconsistent brackets in the past if ERRORLEVEL 2 goto END @if exist a ( echo exists ) else ( echo not ) FOR /L %%G IN (2,1,4) DO (echo %%G) :: Bug 1997: keywords not recognized when preceded by '(' IF NOT DEFINED var (SET var=1) :: Bug 2065: keywords not recognized when followed by ')' @if exist a ( exit) :: Bug: with \r or \n, 'command' is seen as continuation echo word ^ 1 command :: Bug argument and variable expansion echo %~dp0123 echo %%-~012 echo %%~%%~-abcd FOR /F %%I in ("C:\Test\temp.txt") do echo %%~dI :: Bug ending of argument and variable expansion echo %~dp0\123 echo "%~dp0123" echo "%%-~012" echo "%%~%%~-abcd" FOR /F %%I in ("C:\Test\temp.txt") do echo "%%~dI" :: Bug escaped % echo %%0 echo %%%0 echo %%%%~-abcd :TEST that after label style works :: Bug 2304: "::" comments not recognised when second command on line Set /A xxx=%xxx%+1 & :: Increment Set /A xxx=%xxx%+1 & ::Increment Set /A xxx=%xxx%+1 & rem Increment :END tmpok_q575y/lexilla/test/examples/batch/x.bat.folded0000664000175000017500000000404314773064066022255 0ustar gusnangusnan 0 400 0 rem comment=1 0 400 0 rem 'echo' is word=2, 'a' is default=0 0 400 0 echo a 0 400 0 rem label=3 0 400 0 :START 0 400 0 rem '@' is hide=4 0 400 0 @echo b 0 400 0 rem 'gcc' is external command=5 0 400 0 gcc --version 0 400 0 rem '%PATH%' is variable=6 0 400 0 echo %PATH% 0 400 0 echo %ProgramFiles(x86)% 0 400 0 rem operator=7 '=' 0 400 0 @set Q=A 0 400 0 0 400 0 ::comment=1 0 400 0 0 400 0 :: Bug 1624: this construct produced inconsistent brackets in the past 0 400 0 if ERRORLEVEL 2 goto END 0 400 0 @if exist a ( 0 400 0 echo exists 0 400 0 ) else ( 0 400 0 echo not 0 400 0 ) 0 400 0 0 400 0 FOR /L %%G IN (2,1,4) DO (echo %%G) 0 400 0 0 400 0 :: Bug 1997: keywords not recognized when preceded by '(' 0 400 0 IF NOT DEFINED var (SET var=1) 0 400 0 0 400 0 :: Bug 2065: keywords not recognized when followed by ')' 0 400 0 @if exist a ( exit) 0 400 0 0 400 0 :: Bug: with \r or \n, 'command' is seen as continuation 0 400 0 echo word ^ 0 400 0 1 0 400 0 command 0 400 0 0 400 0 :: Bug argument and variable expansion 0 400 0 echo %~dp0123 0 400 0 echo %%-~012 0 400 0 echo %%~%%~-abcd 0 400 0 FOR /F %%I in ("C:\Test\temp.txt") do echo %%~dI 0 400 0 0 400 0 :: Bug ending of argument and variable expansion 0 400 0 echo %~dp0\123 0 400 0 echo "%~dp0123" 0 400 0 echo "%%-~012" 0 400 0 echo "%%~%%~-abcd" 0 400 0 FOR /F %%I in ("C:\Test\temp.txt") do echo "%%~dI" 0 400 0 0 400 0 :: Bug escaped % 0 400 0 echo %%0 0 400 0 echo %%%0 0 400 0 echo %%%%~-abcd 0 400 0 0 400 0 :TEST that after label style works 0 400 0 :: Bug 2304: "::" comments not recognised when second command on line 0 400 0 Set /A xxx=%xxx%+1 & :: Increment 0 400 0 Set /A xxx=%xxx%+1 & ::Increment 0 400 0 Set /A xxx=%xxx%+1 & rem Increment 0 400 0 0 400 0 :END 0 400 0 tmpok_q575y/lexilla/test/examples/batch/Issue222.bat0000664000175000017500000000047614773064066022076 0ustar gusnangusnanrem Keywords with colon rem with spacing call file.bat arg1 call "file.bat" arg1 call :label arg1 goto :label goto :eof goto label echo: %var% echo: text echo text rem no spacing call:label arg1 goto:label goto:eof echo:%var% echo:text (call) (echo:) (goto) rem call internal commands call echo text call set "a=b" tmpok_q575y/lexilla/test/examples/batch/Issue222.bat.folded0000664000175000017500000000123514773064066023324 0ustar gusnangusnan 0 400 0 rem Keywords with colon 0 400 0 0 400 0 rem with spacing 0 400 0 call file.bat arg1 0 400 0 call "file.bat" arg1 0 400 0 call :label arg1 0 400 0 goto :label 0 400 0 goto :eof 0 400 0 goto label 0 400 0 echo: %var% 0 400 0 echo: text 0 400 0 echo text 0 400 0 0 400 0 rem no spacing 0 400 0 call:label arg1 0 400 0 goto:label 0 400 0 goto:eof 0 400 0 echo:%var% 0 400 0 echo:text 0 400 0 (call) 0 400 0 (echo:) 0 400 0 (goto) 0 400 0 0 400 0 rem call internal commands 0 400 0 call echo text 0 400 0 call set "a=b" 0 400 0 tmpok_q575y/lexilla/test/examples/caml/0000775000175000017500000000000014773064066017714 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/caml/AllStyles.ml.folded0000664000175000017500000000237114773064066023421 0ustar gusnangusnan 0 400 0 (* Enumerate all styles: 0 to 15 *) 0 400 0 (* comment=12 *) 0 400 0 0 400 0 (* whitespace=0 *) 0 400 0 (* w *) 0 400 0 0 400 0 (* identifier=1 *) 0 400 0 ident 0 400 0 0 400 0 (* tagname=2 *) 0 400 0 `ident 0 400 0 0 400 0 (* keyword=3 *) 0 400 0 and 0 400 0 0 400 0 (* keyword2=4 *) 0 400 0 None 0 400 0 0 400 0 (* keyword3=5 *) 0 400 0 char 0 400 0 0 400 0 (* linenum=6 *) 0 400 0 #12 0 400 0 0 400 0 (* operator=7 *) 0 400 0 * 0 400 0 0 400 0 (* number=8 *) 0 400 0 12 0 400 0 0 400 0 (* char=9 *) 0 400 0 'a' 0 400 0 0 400 0 (* white=10 *) 0 400 0 (* this state can not be reached in caml mode, only SML mode but that stops other states *) 0 400 0 (* SML mode is triggered by "andalso" being in the keywords *) 0 400 0 "\ \x" 0 400 0 0 400 0 (* string=11 *) 0 400 0 "string" 0 400 0 0 400 0 (* comment1=13 *) 0 400 0 (* (* comment 1 *) *) 0 400 0 0 400 0 (* comment2=14 *) 0 400 0 (* (* (* comment 2 *) *) *) 0 400 0 0 400 0 (* comment3=15 *) 0 400 0 (* (* (* (* comment 1 *) *) *) *) 0 400 0 tmpok_q575y/lexilla/test/examples/caml/SciTE.properties0000664000175000017500000000012314773064066022775 0ustar gusnangusnanlexer.*.ml=caml keywords.*.ml=and xandalso keywords2.*.ml=None keywords3.*.ml=char tmpok_q575y/lexilla/test/examples/caml/AllStyles.ml.styled0000664000175000017500000000160414773064066023466 0ustar gusnangusnan{12}(* Enumerate all styles: 0 to 15 *){0} {12}(* comment=12 *){0} {12}(* whitespace=0 *){0} {12}(* w *){0} {12}(* identifier=1 *){0} {1}ident{0} {12}(* tagname=2 *){0} {2}`ident{0} {12}(* keyword=3 *){0} {3}and{0} {12}(* keyword2=4 *){0} {4}None{0} {12}(* keyword3=5 *){0} {5}char{0} {12}(* linenum=6 *){0} {6}#12{0} {12}(* operator=7 *){0} {7}*{0} {12}(* number=8 *){0} {8}12{0} {12}(* char=9 *){0} {9}'a'{0} {12}(* white=10 *){0} {12}(* this state can not be reached in caml mode, only SML mode but that stops other states *){0} {12}(* SML mode is triggered by "andalso" being in the keywords *){0} {11}"\ \x"{0} {12}(* string=11 *){0} {11}"string"{0} {12}(* comment1=13 *){0} {12}(* {13}(* comment 1 *){12} *){0} {12}(* comment2=14 *){0} {12}(* {13}(* {14}(* comment 2 *){13} *){12} *){0} {12}(* comment3=15 *){0} {12}(* {13}(* {14}(* {15}(* comment 1 *){14} *){13} *){12} *){0} tmpok_q575y/lexilla/test/examples/caml/AllStyles.ml0000664000175000017500000000115714773064066022166 0ustar gusnangusnan(* Enumerate all styles: 0 to 15 *) (* comment=12 *) (* whitespace=0 *) (* w *) (* identifier=1 *) ident (* tagname=2 *) `ident (* keyword=3 *) and (* keyword2=4 *) None (* keyword3=5 *) char (* linenum=6 *) #12 (* operator=7 *) * (* number=8 *) 12 (* char=9 *) 'a' (* white=10 *) (* this state can not be reached in caml mode, only SML mode but that stops other states *) (* SML mode is triggered by "andalso" being in the keywords *) "\ \x" (* string=11 *) "string" (* comment1=13 *) (* (* comment 1 *) *) (* comment2=14 *) (* (* (* comment 2 *) *) *) (* comment3=15 *) (* (* (* (* comment 1 *) *) *) *) tmpok_q575y/lexilla/test/examples/modula/0000775000175000017500000000000014773064066020261 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/modula/128Endless.m3.styled0000664000175000017500000000114014773064066023651 0ustar gusnangusnan{1}(* This file caused an infinite loop in the folder before #128 was fixed.*){0} {4}MODULE{0} Form{16};{0} {4}IMPORT{0} {4}PROCEDURE{0} {16}({0}bf{16}:{0} ButtonForm{16}){0} InitializeComponent{16}(),{0} {5}NEW{16};{0} {4}BEGIN{0} bf{16}.{0}SuspendLayout{16}();{0} REGISTER{16}({0}bf{16}.{0}button1{16}.{0}Click{16},{0} bf{16}.{0}button1_Click{16});{0} bf{16}.{0}get_Controls{16}().{0}Add{16}({0}bf{16}.{0}button2{16});{0} {4}END{0} InitializeComponent{16};{0} {4}BEGIN{0} {5}NEW{16}({0}bf{16});{0} Wfm{16}.{0}Application{16}.{0}Run{16}({0}bf{16});{0} {4}END{0} Form{16}.{0} tmpok_q575y/lexilla/test/examples/modula/Issue129.m3.styled0000664000175000017500000000031214773064066023345 0ustar gusnangusnan{4}INTERFACE{0} Test{16};{0} {4}TYPE{0} {1}(* Opaque types *){0} HANDLE {16}={0} {5}ADDRESS{16};{0} HMOD{1}(* Module handle *){0} {16}={0} HANDLE{16};{0} {4}END{0} Test{16}.{0} tmpok_q575y/lexilla/test/examples/modula/128Endless.m30000664000175000017500000000055514773064066022357 0ustar gusnangusnan(* This file caused an infinite loop in the folder before #128 was fixed.*) MODULE Form; IMPORT PROCEDURE (bf: ButtonForm) InitializeComponent(), NEW; BEGIN bf.SuspendLayout(); REGISTER(bf.button1.Click, bf.button1_Click); bf.get_Controls().Add(bf.button2); END InitializeComponent; BEGIN NEW(bf); Wfm.Application.Run(bf); END Form. tmpok_q575y/lexilla/test/examples/modula/Issue297.m3.styled0000664000175000017500000000024114773064066023354 0ustar gusnangusnan{4}INTERFACE{0} Issue297{16};{0} {4}TYPE{0} INTEGER32 {16}={0} {16}[-{7}16_7fffffff{16}-{6}1{0} {16}..{0} {7}16_7fffffff{16}];{0} {4}END{0} Issue297{16}.{0} tmpok_q575y/lexilla/test/examples/modula/Issue129.m3.folded0000664000175000017500000000036414773064066023305 0ustar gusnangusnan 0 400 400 INTERFACE Test; 1 400 400 0 400 400 TYPE 0 400 400 (* Opaque types *) 0 400 400 HANDLE = ADDRESS; 0 400 400 HMOD(* Module handle *) = HANDLE; 1 400 400 0 400 3ff END Test. 1 3ff 3ff tmpok_q575y/lexilla/test/examples/modula/SciTE.properties0000664000175000017500000000205314773064066023346 0ustar gusnangusnanlexer.*.m3=modula # Keywords keywords.*.m3=AND ANY ARRAY AS BEGIN BITS BRANDED BY CASE CONST\ DIV DO ELSE ELSIF END EVAL EXCEPT EXCEPTION EXIT EXPORTS FINALLY FOR FROM\ GENERIC IF IMPORT IN INTERFACE LOCK LOOP METHODS MOD MODULE NOT OBJECT OF\ OR OVERRIDES PROCEDURE RAISE RAISES READONLY RECORD REF REPEAT RETURN\ REVEAL ROOT SET THEN TO TRY TYPE TYPECASE UNSAFE UNTIL UNTRACED VALUE VAR\ WHILE WITH # Reserved identifiers keywords2.*.m3=ABS ADDRESS ADR ADRSIZE BITSIZE BOOLEAN BYTESIZE\ CARDINAL CEILING CHAR DEC DISPOSE EXTENDED FALSE FIRST FLOAT FLOOR INC\ INTEGER ISTYPE LAST LONGINT LONGREAL LOOPHOLE MAX MIN MUTEX NARROW NEW NIL\ NULL NUMBER ORD REAL REFANY ROUND SUBARRAY TEXT TRUE TRUNC TYPECODE VAL\ WIDECHAR # Operators keywords3.*.m3= + < # = ; .. : - > { } | := <: * <= ( ) ^ , =>\ / >= [ ] . & # Pragmas keywords keywords4.*.m3= EXTERNAL INLINE ASSERT TRACE FATAL UNUSED\ OBSOLETE NOWARN LINE PRAGMA # Escape sequences keywords5.*.m3= f n r t \ " ' # Doxygene keywords keywords6.*.m3= author authors file brief date proc param result fold=1 tmpok_q575y/lexilla/test/examples/modula/Issue129.m30000664000175000017500000000017714773064066022053 0ustar gusnangusnanINTERFACE Test; TYPE (* Opaque types *) HANDLE = ADDRESS; HMOD(* Module handle *) = HANDLE; END Test. tmpok_q575y/lexilla/test/examples/modula/Issue297.m3.folded0000664000175000017500000000026314773064066023311 0ustar gusnangusnan 0 400 400 INTERFACE Issue297; 1 400 400 0 400 400 TYPE 0 400 400 INTEGER32 = [-16_7fffffff-1 .. 16_7fffffff]; 1 400 400 0 400 3ff END Issue297. 1 3ff 3ff tmpok_q575y/lexilla/test/examples/modula/128Endless.m3.folded0000664000175000017500000000107514773064066023611 0ustar gusnangusnan 0 400 400 (* This file caused an infinite loop in the folder before #128 was fixed.*) 0 400 400 MODULE Form; 0 400 400 IMPORT 1 400 400 0 400 400 PROCEDURE (bf: ButtonForm) InitializeComponent(), NEW; 2 400 401 + BEGIN 0 401 401 | bf.SuspendLayout(); 0 401 401 | REGISTER(bf.button1.Click, bf.button1_Click); 0 401 401 | bf.get_Controls().Add(bf.button2); 0 401 400 | END InitializeComponent; 1 400 400 2 400 401 + BEGIN 0 401 401 | NEW(bf); 0 401 401 | Wfm.Application.Run(bf); 0 401 400 | END Form. 1 400 400 tmpok_q575y/lexilla/test/examples/modula/Issue297.m30000664000175000017500000000013014773064066022046 0ustar gusnangusnanINTERFACE Issue297; TYPE INTEGER32 = [-16_7fffffff-1 .. 16_7fffffff]; END Issue297. tmpok_q575y/lexilla/test/examples/zig/0000775000175000017500000000000014773064066017571 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/zig/AllStyles.zig.styled0000664000175000017500000003234714773064066023534 0ustar gusnangusnan{1}// coding:utf-8 {0} {2}/// A structure for storing a timestamp, with nanosecond precision (this is a /// multiline doc comment). {13}const{0} {15}Timestamp{0} {5}={0} {13}struct{0} {5}{{0} {2}/// The number of seconds since the epoch (this is also a doc comment). {0} {10}seconds{5}:{0} {14}i64{5},{0} {1}// signed so we can represent pre-1970 (not a doc comment) {0} {2}/// The number of nanoseconds past the second (doc comment again). {0} {10}nanos{5}:{0} {14}u32{5},{0} {2}/// Returns a `Timestamp` struct representing the Unix epoch; that is, the {0} {2}/// moment of 1970 Jan 1 00:00:00 UTC (this is a doc comment too). {0} {13}pub{0} {13}fn{0} {11}unixEpoch{5}(){0} {15}Timestamp{0} {5}{{0} {13}return{0} {15}Timestamp{5}{{0} {5}.{10}seconds{0} {5}={0} {4}0{5},{0} {5}.{10}nanos{0} {5}={0} {4}0{5},{0} {5}};{0} {5}}{0} {5}};{0} {3}//! This module provides functions for retrieving the current date and //! time with varying degrees of precision and accuracy. It does not //! depend on libc, but will use functions from it if available. {0} {13}const{0} {10}S{0} {5}={0} {13}struct{0} {5}{{0} {3}//! Top level comments are allowed inside a container other than a module, {0} {3}//! but it is not very useful. Currently, when producing the package {0} {3}//! documentation, these comments are ignored. {5}};{0} {13}const{0} {10}std{0} {5}={0} {12}@import{5}({7}"std"{5});{0} {13}pub{0} {13}fn{0} {11}main{5}(){0} {5}!{14}void{0} {5}{{0} {13}const{0} {10}stdout{0} {5}={0} {10}std{5}.{10}io{5}.{10}getStdOut{5}().{10}writer{5}();{0} {13}try{0} {10}stdout{5}.{10}print{5}({7}"Hello, {s}!{9}\n{7}"{5},{0} {5}.{{7}"world"{5}});{0} {5}}{0} {1}// Top-level declarations are order-independent: {13}const{0} {10}print{0} {5}={0} {10}std{5}.{10}debug{5}.{10}print{5};{0} {13}const{0} {10}std{0} {5}={0} {12}@import{5}({7}"std"{5});{0} {13}const{0} {10}os{0} {5}={0} {10}std{5}.{10}os{5};{0} {13}const{0} {13}assert{0} {5}={0} {10}std{5}.{10}debug{5}.{13}assert{5};{0} {13}pub{0} {13}fn{0} {11}main{5}(){0} {14}void{0} {5}{{0} {1}// integers {0} {13}const{0} {10}one_plus_one{5}:{0} {14}i32{0} {5}={0} {4}1{0} {5}+{0} {4}1{5};{0} {10}print{5}({7}"1 + 1 = {}{9}\n{7}"{5},{0} {5}.{{10}one_plus_one{5}});{0} {1}// floats {0} {13}const{0} {10}seven_div_three{5}:{0} {14}f32{0} {5}={0} {4}7.0{0} {5}/{0} {4}3.0{5};{0} {10}print{5}({7}"7.0 / 3.0 = {}{9}\n{7}"{5},{0} {5}.{{10}seven_div_three{5}});{0} {1}// boolean {0} {10}print{5}({7}"{}{9}\n{7}{}{9}\n{7}{}{9}\n{7}"{5},{0} {5}.{{0} {13}true{0} {13}and{0} {13}false{5},{0} {13}true{0} {13}or{0} {13}false{5},{0} {5}!{13}true{5},{0} {5}});{0} {1}// optional {0} {13}var{0} {10}optional_value{5}:{0} {5}?[]{13}const{0} {14}u8{0} {5}={0} {13}null{5};{0} {13}assert{5}({10}optional_value{0} {5}=={0} {13}null{5});{0} {10}print{5}({7}"{9}\n{7}optional 1{9}\n{7}type: {}{9}\n{7}value: {?s}{9}\n{7}"{5},{0} {5}.{{0} {12}@TypeOf{5}({10}optional_value{5}),{0} {10}optional_value{5},{0} {5}});{0} {10}optional_value{0} {5}={0} {7}"hi"{5};{0} {13}assert{5}({10}optional_value{0} {5}!={0} {13}null{5});{0} {10}print{5}({7}"{9}\n{7}optional 2{9}\n{7}type: {}{9}\n{7}value: {?s}{9}\n{7}"{5},{0} {5}.{{0} {12}@TypeOf{5}({10}optional_value{5}),{0} {10}optional_value{5},{0} {5}});{0} {1}// error union {0} {13}var{0} {10}number_or_error{5}:{0} {14}anyerror{5}!{14}i32{0} {5}={0} {13}error{5}.{10}ArgNotFound{5};{0} {10}print{5}({7}"{9}\n{7}error union 1{9}\n{7}type: {}{9}\n{7}value: {!}{9}\n{7}"{5},{0} {5}.{{0} {12}@TypeOf{5}({10}number_or_error{5}),{0} {10}number_or_error{5},{0} {5}});{0} {10}number_or_error{0} {5}={0} {4}1234{5};{0} {10}print{5}({7}"{9}\n{7}error union 2{9}\n{7}type: {}{9}\n{7}value: {!}{9}\n{7}"{5},{0} {5}.{{0} {12}@TypeOf{5}({10}number_or_error{5}),{0} {10}number_or_error{5},{0} {5}});{0} {5}}{0} {13}const{0} {10}print{0} {5}={0} {12}@import{5}({7}"std"{5}).{10}debug{5}.{10}print{5};{0} {13}const{0} {10}mem{0} {5}={0} {12}@import{5}({7}"std"{5}).{10}mem{5};{0} {1}// will be used to compare bytes {0} {13}pub{0} {13}fn{0} {11}main{5}(){0} {14}void{0} {5}{{0} {13}const{0} {10}bytes{0} {5}={0} {7}"hello{9}\u{12345678}{7}"{5};{0} {10}print{5}({7}"{}{9}\n{7}"{5},{0} {5}.{{12}@TypeOf{5}({10}bytes{5})});{0} {1}// *const [5:0]u8 {0} {10}print{5}({7}"{d}{9}\n{7}"{5},{0} {5}.{{10}bytes{5}.{10}len{5}});{0} {1}// 5 {0} {10}print{5}({7}"{c}{9}\n{7}"{5},{0} {5}.{{10}bytes{5}[{4}1{5}]});{0} {1}// 'e' {0} {10}print{5}({7}"{d}{9}\n{7}"{5},{0} {5}.{{10}bytes{5}[{4}5{5}]});{0} {1}// 0 {0} {10}print{5}({7}"{}{9}\n{7}"{5},{0} {5}.{{6}'e'{0} {5}=={0} {6}'{9}\x65{6}'{5}});{0} {1}// true {0} {10}print{5}({7}"{d}{9}\n{7}"{5},{0} {5}.{{6}'{9}\u{1f4a9}{6}'{5}});{0} {1}// 128169 {0} {10}print{5}({7}"{d}{9}\n{7}"{5},{0} {5}.{{6}'💯'{5}});{0} {1}// 128175 {0} {10}print{5}({7}"{u}{9}\n{7}"{5},{0} {5}.{{6}'âš¡'{5}});{0} {10}print{5}({7}"{}{9}\n{7}"{5},{0} {5}.{{10}mem{5}.{10}eql{5}({14}u8{5},{0} {7}"hello"{5},{0} {7}"h{9}\x65{7}llo"{5})});{0} {1}// true {0} {10}print{5}({7}"{}{9}\n{7}"{5},{0} {5}.{{10}mem{5}.{10}eql{5}({14}u8{5},{0} {7}"💯"{5},{0} {7}"{9}\xf0\x9f\x92\xaf{7}"{5})});{0} {1}// also true {0} {13}const{0} {10}invalid_utf8{0} {5}={0} {7}"{9}\xff\xfe{7}"{5};{0} {1}// non-UTF-8 strings are possible with \xNN notation. {0} {10}print{5}({7}"0x{x}{9}\n{7}"{5},{0} {5}.{{10}invalid_utf8{5}[{4}1{5}]});{0} {1}// indexing them returns individual bytes... {0} {10}print{5}({7}"0x{x}{9}\n{7}"{5},{0} {5}.{{7}"💯"{5}[{4}1{5}]});{0} {1}// ...as does indexing part-way through non-ASCII characters {5}}{0} {13}const{0} {10}hello_world_in_c{0} {5}={0} {8}\\#include {0} {8}\\ {0} {8}\\int main(int argc, char **argv) { {0} {8}\\ printf("hello world\n"); {0} {8}\\ return 0; {0} {8}\\} {5};{0} {13}const{0} {10}std{0} {5}={0} {12}@import{5}({7}"std"{5});{0} {13}const{0} {13}assert{0} {5}={0} {10}std{5}.{10}debug{5}.{13}assert{5};{0} {13}threadlocal{0} {13}var{0} {10}x{5}:{0} {14}i32{0} {5}={0} {4}1234{5};{0} {13}test{0} {7}"thread local storage"{0} {5}{{0} {13}const{0} {10}thread1{0} {5}={0} {13}try{0} {10}std{5}.{10}Thread{5}.{10}spawn{5}(.{},{0} {10}testTls{5},{0} {5}.{});{0} {13}const{0} {10}thread2{0} {5}={0} {13}try{0} {10}std{5}.{10}Thread{5}.{10}spawn{5}(.{},{0} {10}testTls{5},{0} {5}.{});{0} {10}testTls{5}();{0} {10}thread1{5}.{10}join{5}();{0} {10}thread2{5}.{10}join{5}();{0} {5}}{0} {13}fn{0} {11}testTls{5}(){0} {14}void{0} {5}{{0} {13}assert{5}({10}x{0} {5}=={0} {4}1234{5});{0} {10}x{0} {5}+={0} {4}1{5};{0} {13}assert{5}({10}x{0} {5}=={0} {4}1235{5});{0} {5}}{0} {13}const{0} {10}decimal_int{0} {5}={0} {4}98222{5};{0} {13}const{0} {10}hex_int{0} {5}={0} {4}0xff{5};{0} {13}const{0} {10}another_hex_int{0} {5}={0} {4}0xFF{5};{0} {13}const{0} {10}octal_int{0} {5}={0} {4}0o755{5};{0} {13}const{0} {10}binary_int{0} {5}={0} {4}0b11110000{5};{0} {1}// underscores may be placed between two digits as a visual separator {13}const{0} {10}one_billion{0} {5}={0} {4}1_000_000_000{5};{0} {13}const{0} {10}binary_mask{0} {5}={0} {4}0b1_1111_1111{5};{0} {13}const{0} {10}permissions{0} {5}={0} {4}0o7_5_5{5};{0} {13}const{0} {10}big_address{0} {5}={0} {4}0xFF80_0000_0000_0000{5};{0} {13}const{0} {10}floating_point{0} {5}={0} {4}123.0E+77{5};{0} {13}const{0} {10}another_float{0} {5}={0} {4}123.0{5};{0} {13}const{0} {10}yet_another{0} {5}={0} {4}123.0e+77{5};{0} {13}const{0} {10}hex_floating_point{0} {5}={0} {4}0x103.70p{5}-{4}5{5};{0} {13}const{0} {10}another_hex_float{0} {5}={0} {4}0x103.70{5};{0} {13}const{0} {10}yet_another_hex_float{0} {5}={0} {4}0x103.70P{5}-{4}5{5};{0} {1}// underscores may be placed between two digits as a visual separator {13}const{0} {10}lightspeed{0} {5}={0} {4}299_792_458.000_000{5};{0} {13}const{0} {10}nanosecond{0} {5}={0} {4}0.000_000_001{5};{0} {13}const{0} {10}more_hex{0} {5}={0} {4}0x1234_5678.9ABC_CDEFp{5}-{4}10{5};{0} {13}const{0} {16}Vec3{0} {5}={0} {13}struct{0} {5}{{0} {10}x{5}:{0} {14}f32{5},{0} {10}y{5}:{0} {14}f32{5},{0} {10}z{5}:{0} {14}f32{5},{0} {13}pub{0} {13}fn{0} {11}init{5}({10}x{5}:{0} {14}f32{5},{0} {10}y{5}:{0} {14}f32{5},{0} {10}z{5}:{0} {14}f32{5}){0} {16}Vec3{0} {5}{{0} {13}return{0} {16}Vec3{5}{{0} {5}.{10}x{0} {5}={0} {10}x{5},{0} {5}.{10}y{0} {5}={0} {10}y{5},{0} {5}.{10}z{0} {5}={0} {10}z{5},{0} {5}};{0} {5}}{0} {13}pub{0} {13}fn{0} {11}dot{5}({10}self{5}:{0} {16}Vec3{5},{0} {10}other{5}:{0} {16}Vec3{5}){0} {14}f32{0} {5}{{0} {13}return{0} {10}self{5}.{10}x{0} {5}*{0} {10}other{5}.{10}x{0} {5}+{0} {10}self{5}.{10}y{0} {5}*{0} {10}other{5}.{10}y{0} {5}+{0} {10}self{5}.{10}z{0} {5}*{0} {10}other{5}.{10}z{5};{0} {5}}{0} {5}};{0} {13}fn{0} {11}LinkedList{5}({13}comptime{0} {10}T{5}:{0} {14}type{5}){0} {14}type{0} {5}{{0} {13}return{0} {13}struct{0} {5}{{0} {13}pub{0} {13}const{0} {10}Node{0} {5}={0} {13}struct{0} {5}{{0} {10}prev{5}:{0} {5}?*{10}Node{5},{0} {10}next{5}:{0} {5}?*{10}Node{5},{0} {10}data{5}:{0} {10}T{5},{0} {5}};{0} {10}first{5}:{0} {5}?*{10}Node{5},{0} {10}last{5}:{0} {5}?*{10}Node{5},{0} {10}len{5}:{0} {14}usize{5},{0} {5}};{0} {5}}{0} {13}const{0} {10}Point{0} {5}={0} {13}struct{0} {5}{{0} {10}x{5}:{0} {14}f32{5},{0} {10}y{5}:{0} {14}f32{5},{0} {5}};{0} {1}// Maybe we want to pass it to OpenGL so we want to be particular about // how the bytes are arranged. {13}const{0} {10}Point2{0} {5}={0} {13}packed{0} {13}struct{0} {5}{{0} {10}x{5}:{0} {14}f32{5},{0} {10}y{5}:{0} {14}f32{5},{0} {5}};{0} {13}const{0} {10}std{0} {5}={0} {12}@import{5}({7}"std"{5});{0} {13}const{0} {10}expect{0} {5}={0} {10}std{5}.{10}testing{5}.{10}expect{5};{0} {13}const{0} {10}Color{0} {5}={0} {13}enum{0} {5}{{0} {10}auto{5},{0} {10}off{5},{0} {10}on{5},{0} {5}};{0} {13}const{0} {10}std{0} {5}={0} {12}@import{5}({7}"std"{5});{0} {13}const{0} {10}builtin{0} {5}={0} {12}@import{5}({7}"builtin"{5});{0} {13}const{0} {10}expect{0} {5}={0} {10}std{5}.{10}testing{5}.{10}expect{5};{0} {13}test{0} {7}"switch simple"{0} {5}{{0} {13}const{0} {10}a{5}:{0} {14}u64{0} {5}={0} {4}10{5};{0} {13}const{0} {10}zz{5}:{0} {14}u64{0} {5}={0} {4}103{5};{0} {1}// All branches of a switch expression must be able to be coerced to a {0} {1}// common type. {0} {1}// {0} {1}// Branches cannot fallthrough. If fallthrough behavior is desired, combine {0} {1}// the cases and use an if. {0} {13}const{0} {10}b{0} {5}={0} {13}switch{0} {5}({10}a{5}){0} {5}{{0} {1}// Multiple cases can be combined via a ',' {0} {4}1{5},{0} {4}2{5},{0} {4}3{0} {5}=>{0} {4}0{5},{0} {1}// Ranges can be specified using the ... syntax. These are inclusive {0} {1}// of both ends. {0} {4}5{5}..{4}.100{0} {5}=>{0} {4}1{5},{0} {1}// Branches can be arbitrarily complex. {0} {4}101{0} {5}=>{0} {10}blk{5}:{0} {5}{{0} {13}const{0} {10}c{5}:{0} {14}u64{0} {5}={0} {4}5{5};{0} {13}break{0} {5}:{10}blk{0} {10}c{0} {5}*{0} {4}2{0} {5}+{0} {4}1{5};{0} {5}},{0} {1}// Switching on arbitrary expressions is allowed as long as the {0} {1}// expression is known at compile-time. {0} {10}zz{0} {5}=>{0} {10}zz{5},{0} {10}blk{5}:{0} {5}{{0} {13}const{0} {10}d{5}:{0} {14}u32{0} {5}={0} {4}5{5};{0} {13}const{0} {10}e{5}:{0} {14}u32{0} {5}={0} {4}100{5};{0} {13}break{0} {5}:{10}blk{0} {10}d{0} {5}+{0} {10}e{5};{0} {5}}{0} {5}=>{0} {4}107{5},{0} {1}// The else branch catches everything not already captured. {0} {1}// Else branches are mandatory unless the entire range of values {0} {1}// is handled. {0} {13}else{0} {5}=>{0} {4}9{5},{0} {5}};{0} {13}try{0} {10}expect{5}({10}b{0} {5}=={0} {4}1{5});{0} {5}}{0} {13}fn{0} {11}charToDigit{5}({10}c{5}:{0} {14}u8{5}){0} {14}u8{0} {5}{{0} {13}return{0} {13}switch{0} {5}({10}c{5}){0} {5}{{0} {6}'0'{5}...{6}'9'{0} {5}=>{0} {10}c{0} {5}-{0} {6}'0'{5},{0} {6}'A'{5}...{6}'Z'{0} {5}=>{0} {10}c{0} {5}-{0} {6}'A'{0} {5}+{0} {4}10{5},{0} {6}'a'{5}...{6}'z'{0} {5}=>{0} {10}c{0} {5}-{0} {6}'a'{0} {5}+{0} {4}10{5},{0} {13}else{0} {5}=>{0} {10}maxInt{5}({14}u8{5}),{0} {5}};{0} {5}}{0} {13}const{0} {10}optional_value{5}:{0} {5}?{14}i32{0} {5}={0} {13}null{5};{0} {3}//! This module provides functions for retrieving the current date and //! time with varying degrees of precision and accuracy. It does not //! depend on libc, but will use functions from it if available. {0} {13}const{0} {17}@"identifier with spaces in it"{0} {5}={0} {4}0xff{5};{0} {13}const{0} {17}@"1SmallStep4Man"{0} {5}={0} {4}112358{5};{0} {13}const{0} {10}c{0} {5}={0} {12}@import{5}({7}"std"{5}).{10}c{5};{0} {13}pub{0} {13}extern{0} {7}"c"{0} {13}fn{0} {17}@"error"{5}(){0} {11}void{5};{0} {13}pub{0} {13}extern{0} {7}"c"{0} {13}fn{0} {17}@"fstat$INODE64"{5}({11}fd{5}:{0} {10}c{5}.{10}fd_t{5},{0} {10}buf{5}:{0} {5}*{10}c{5}.{10}Stat{5}){0} {10}c_int{5};{0} {13}const{0} {10}Color{0} {5}={0} {13}enum{0} {5}{{0} {10}red{5},{0} {17}@"really red"{5},{0} {5}};{0} {13}const{0} {10}color{5}:{0} {10}Color{0} {5}={0} {5}.{17}@"really red"{5};{0} tmpok_q575y/lexilla/test/examples/zig/AllStyles.zig.folded0000664000175000017500000002620314773064066023457 0ustar gusnangusnan 0 400 400 // coding:utf-8 0 400 400 2 400 401 + /// A structure for storing a timestamp, with nanosecond precision (this is a 0 401 400 | /// multiline doc comment). 2 400 401 + const Timestamp = struct { 0 401 401 | /// The number of seconds since the epoch (this is also a doc comment). 0 401 401 | seconds: i64, // signed so we can represent pre-1970 (not a doc comment) 0 401 401 | /// The number of nanoseconds past the second (doc comment again). 0 401 401 | nanos: u32, 0 401 401 | 2 401 402 + /// Returns a `Timestamp` struct representing the Unix epoch; that is, the 0 402 401 | /// moment of 1970 Jan 1 00:00:00 UTC (this is a doc comment too). 2 401 402 + pub fn unixEpoch() Timestamp { 2 402 403 + return Timestamp{ 0 403 403 | .seconds = 0, 0 403 403 | .nanos = 0, 0 403 402 | }; 0 402 401 | } 0 401 400 | }; 0 400 400 2 400 401 + //! This module provides functions for retrieving the current date and 0 401 401 | //! time with varying degrees of precision and accuracy. It does not 0 401 400 | //! depend on libc, but will use functions from it if available. 0 400 400 2 400 401 + const S = struct { 2 401 402 + //! Top level comments are allowed inside a container other than a module, 0 402 402 | //! but it is not very useful. Currently, when producing the package 0 402 401 | //! documentation, these comments are ignored. 0 401 400 | }; 0 400 400 0 400 400 const std = @import("std"); 0 400 400 2 400 401 + pub fn main() !void { 0 401 401 | const stdout = std.io.getStdOut().writer(); 0 401 401 | try stdout.print("Hello, {s}!\n", .{"world"}); 0 401 400 | } 0 400 400 0 400 400 0 400 400 // Top-level declarations are order-independent: 0 400 400 const print = std.debug.print; 0 400 400 const std = @import("std"); 0 400 400 const os = std.os; 0 400 400 const assert = std.debug.assert; 0 400 400 2 400 401 + pub fn main() void { 0 401 401 | // integers 0 401 401 | const one_plus_one: i32 = 1 + 1; 0 401 401 | print("1 + 1 = {}\n", .{one_plus_one}); 0 401 401 | 0 401 401 | // floats 0 401 401 | const seven_div_three: f32 = 7.0 / 3.0; 0 401 401 | print("7.0 / 3.0 = {}\n", .{seven_div_three}); 0 401 401 | 0 401 401 | // boolean 2 401 403 + print("{}\n{}\n{}\n", .{ 0 403 403 | true and false, 0 403 403 | true or false, 0 403 403 | !true, 0 403 401 | }); 0 401 401 | 0 401 401 | // optional 0 401 401 | var optional_value: ?[]const u8 = null; 0 401 401 | assert(optional_value == null); 0 401 401 | 2 401 403 + print("\noptional 1\ntype: {}\nvalue: {?s}\n", .{ 0 403 403 | @TypeOf(optional_value), optional_value, 0 403 401 | }); 0 401 401 | 0 401 401 | optional_value = "hi"; 0 401 401 | assert(optional_value != null); 0 401 401 | 2 401 403 + print("\noptional 2\ntype: {}\nvalue: {?s}\n", .{ 0 403 403 | @TypeOf(optional_value), optional_value, 0 403 401 | }); 0 401 401 | 0 401 401 | // error union 0 401 401 | var number_or_error: anyerror!i32 = error.ArgNotFound; 0 401 401 | 2 401 403 + print("\nerror union 1\ntype: {}\nvalue: {!}\n", .{ 0 403 403 | @TypeOf(number_or_error), 0 403 403 | number_or_error, 0 403 401 | }); 0 401 401 | 0 401 401 | number_or_error = 1234; 0 401 401 | 2 401 403 + print("\nerror union 2\ntype: {}\nvalue: {!}\n", .{ 0 403 403 | @TypeOf(number_or_error), number_or_error, 0 403 401 | }); 0 401 400 | } 0 400 400 0 400 400 const print = @import("std").debug.print; 0 400 400 const mem = @import("std").mem; // will be used to compare bytes 0 400 400 2 400 401 + pub fn main() void { 0 401 401 | const bytes = "hello\u{12345678}"; 0 401 401 | print("{}\n", .{@TypeOf(bytes)}); // *const [5:0]u8 0 401 401 | print("{d}\n", .{bytes.len}); // 5 0 401 401 | print("{c}\n", .{bytes[1]}); // 'e' 0 401 401 | print("{d}\n", .{bytes[5]}); // 0 0 401 401 | print("{}\n", .{'e' == '\x65'}); // true 0 401 401 | print("{d}\n", .{'\u{1f4a9}'}); // 128169 0 401 401 | print("{d}\n", .{'💯'}); // 128175 0 401 401 | print("{u}\n", .{'âš¡'}); 0 401 401 | print("{}\n", .{mem.eql(u8, "hello", "h\x65llo")}); // true 0 401 401 | print("{}\n", .{mem.eql(u8, "💯", "\xf0\x9f\x92\xaf")}); // also true 0 401 401 | const invalid_utf8 = "\xff\xfe"; // non-UTF-8 strings are possible with \xNN notation. 0 401 401 | print("0x{x}\n", .{invalid_utf8[1]}); // indexing them returns individual bytes... 0 401 401 | print("0x{x}\n", .{"💯"[1]}); // ...as does indexing part-way through non-ASCII characters 0 401 400 | } 0 400 400 0 400 400 const hello_world_in_c = 2 400 401 + \\#include 0 401 401 | \\ 0 401 401 | \\int main(int argc, char **argv) { 0 401 401 | \\ printf("hello world\n"); 0 401 401 | \\ return 0; 0 401 400 | \\} 0 400 400 ; 0 400 400 0 400 400 const std = @import("std"); 0 400 400 const assert = std.debug.assert; 0 400 400 0 400 400 threadlocal var x: i32 = 1234; 0 400 400 2 400 401 + test "thread local storage" { 0 401 401 | const thread1 = try std.Thread.spawn(.{}, testTls, .{}); 0 401 401 | const thread2 = try std.Thread.spawn(.{}, testTls, .{}); 0 401 401 | testTls(); 0 401 401 | thread1.join(); 0 401 401 | thread2.join(); 0 401 400 | } 0 400 400 2 400 401 + fn testTls() void { 0 401 401 | assert(x == 1234); 0 401 401 | x += 1; 0 401 401 | assert(x == 1235); 0 401 400 | } 0 400 400 0 400 400 const decimal_int = 98222; 0 400 400 const hex_int = 0xff; 0 400 400 const another_hex_int = 0xFF; 0 400 400 const octal_int = 0o755; 0 400 400 const binary_int = 0b11110000; 0 400 400 0 400 400 // underscores may be placed between two digits as a visual separator 0 400 400 const one_billion = 1_000_000_000; 0 400 400 const binary_mask = 0b1_1111_1111; 0 400 400 const permissions = 0o7_5_5; 0 400 400 const big_address = 0xFF80_0000_0000_0000; 0 400 400 0 400 400 0 400 400 const floating_point = 123.0E+77; 0 400 400 const another_float = 123.0; 0 400 400 const yet_another = 123.0e+77; 0 400 400 0 400 400 const hex_floating_point = 0x103.70p-5; 0 400 400 const another_hex_float = 0x103.70; 0 400 400 const yet_another_hex_float = 0x103.70P-5; 0 400 400 0 400 400 // underscores may be placed between two digits as a visual separator 0 400 400 const lightspeed = 299_792_458.000_000; 0 400 400 const nanosecond = 0.000_000_001; 0 400 400 const more_hex = 0x1234_5678.9ABC_CDEFp-10; 0 400 400 2 400 401 + const Vec3 = struct { 0 401 401 | x: f32, 0 401 401 | y: f32, 0 401 401 | z: f32, 0 401 401 | 2 401 402 + pub fn init(x: f32, y: f32, z: f32) Vec3 { 2 402 403 + return Vec3{ 0 403 403 | .x = x, 0 403 403 | .y = y, 0 403 403 | .z = z, 0 403 402 | }; 0 402 401 | } 0 401 401 | 2 401 402 + pub fn dot(self: Vec3, other: Vec3) f32 { 0 402 402 | return self.x * other.x + self.y * other.y + self.z * other.z; 0 402 401 | } 0 401 400 | }; 0 400 400 2 400 401 + fn LinkedList(comptime T: type) type { 2 401 402 + return struct { 2 402 403 + pub const Node = struct { 0 403 403 | prev: ?*Node, 0 403 403 | next: ?*Node, 0 403 403 | data: T, 0 403 402 | }; 0 402 402 | 0 402 402 | first: ?*Node, 0 402 402 | last: ?*Node, 0 402 402 | len: usize, 0 402 401 | }; 0 401 400 | } 0 400 400 2 400 401 + const Point = struct { 0 401 401 | x: f32, 0 401 401 | y: f32, 0 401 400 | }; 0 400 400 2 400 401 + // Maybe we want to pass it to OpenGL so we want to be particular about 0 401 400 | // how the bytes are arranged. 2 400 401 + const Point2 = packed struct { 0 401 401 | x: f32, 0 401 401 | y: f32, 0 401 400 | }; 0 400 400 0 400 400 0 400 400 const std = @import("std"); 0 400 400 const expect = std.testing.expect; 0 400 400 2 400 401 + const Color = enum { 0 401 401 | auto, 0 401 401 | off, 0 401 401 | on, 0 401 400 | }; 0 400 400 0 400 400 const std = @import("std"); 0 400 400 const builtin = @import("builtin"); 0 400 400 const expect = std.testing.expect; 0 400 400 2 400 401 + test "switch simple" { 0 401 401 | const a: u64 = 10; 0 401 401 | const zz: u64 = 103; 0 401 401 | 2 401 402 + // All branches of a switch expression must be able to be coerced to a 0 402 402 | // common type. 0 402 402 | // 0 402 402 | // Branches cannot fallthrough. If fallthrough behavior is desired, combine 0 402 401 | // the cases and use an if. 2 401 402 + const b = switch (a) { 0 402 402 | // Multiple cases can be combined via a ',' 0 402 402 | 1, 2, 3 => 0, 0 402 402 | 2 402 403 + // Ranges can be specified using the ... syntax. These are inclusive 0 403 402 | // of both ends. 0 402 402 | 5...100 => 1, 0 402 402 | 0 402 402 | // Branches can be arbitrarily complex. 2 402 403 + 101 => blk: { 0 403 403 | const c: u64 = 5; 0 403 403 | break :blk c * 2 + 1; 0 403 402 | }, 0 402 402 | 2 402 403 + // Switching on arbitrary expressions is allowed as long as the 0 403 402 | // expression is known at compile-time. 0 402 402 | zz => zz, 2 402 403 + blk: { 0 403 403 | const d: u32 = 5; 0 403 403 | const e: u32 = 100; 0 403 403 | break :blk d + e; 0 403 402 | } => 107, 0 402 402 | 2 402 403 + // The else branch catches everything not already captured. 0 403 403 | // Else branches are mandatory unless the entire range of values 0 403 402 | // is handled. 0 402 402 | else => 9, 0 402 401 | }; 0 401 401 | 0 401 401 | try expect(b == 1); 0 401 400 | } 0 400 400 2 400 401 + fn charToDigit(c: u8) u8 { 2 401 402 + return switch (c) { 0 402 402 | '0'...'9' => c - '0', 0 402 402 | 'A'...'Z' => c - 'A' + 10, 0 402 402 | 'a'...'z' => c - 'a' + 10, 0 402 402 | else => maxInt(u8), 0 402 401 | }; 0 401 400 | } 0 400 400 0 400 400 const optional_value: ?i32 = null; 0 400 400 2 400 401 + //! This module provides functions for retrieving the current date and 0 401 401 | //! time with varying degrees of precision and accuracy. It does not 0 401 400 | //! depend on libc, but will use functions from it if available. 0 400 400 0 400 400 const @"identifier with spaces in it" = 0xff; 0 400 400 const @"1SmallStep4Man" = 112358; 0 400 400 0 400 400 const c = @import("std").c; 0 400 400 pub extern "c" fn @"error"() void; 0 400 400 pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int; 0 400 400 2 400 401 + const Color = enum { 0 401 401 | red, 0 401 401 | @"really red", 0 401 400 | }; 0 400 400 const color: Color = .@"really red"; 0 400 0 tmpok_q575y/lexilla/test/examples/zig/SciTE.properties0000664000175000017500000000143014773064066022654 0ustar gusnangusnanlexer.*.zig=zig fold=1 keywords.*.zig=False None True _ and as assert async await break case class continue def del elif else except finally for from global if import in is lambda match nonlocal not or pass raise return try while with yield addrspace align allowzero and anyframe anytype asm async await break callconv catch comptime const continue defer else enum errdefer error export extern false fn for if inline linksection noalias noinline nosuspend null opaque or orelse packed pub resume return struct suspend switch test threadlocal true try undefined union unreachable usingnamespace var volatile while keywords2.*.zig=anyerror anyopaque bool f128 f16 f32 f64 f80 i128 i16 i32 i64 i8 isize noreturn type u128 u16 u32 u64 u8 usize void keywords3.*.zig=Timestamp keywords4.*.zig=Vec3 tmpok_q575y/lexilla/test/examples/zig/AllStyles.zig0000664000175000017500000001667414773064066022236 0ustar gusnangusnan// coding:utf-8 /// A structure for storing a timestamp, with nanosecond precision (this is a /// multiline doc comment). const Timestamp = struct { /// The number of seconds since the epoch (this is also a doc comment). seconds: i64, // signed so we can represent pre-1970 (not a doc comment) /// The number of nanoseconds past the second (doc comment again). nanos: u32, /// Returns a `Timestamp` struct representing the Unix epoch; that is, the /// moment of 1970 Jan 1 00:00:00 UTC (this is a doc comment too). pub fn unixEpoch() Timestamp { return Timestamp{ .seconds = 0, .nanos = 0, }; } }; //! This module provides functions for retrieving the current date and //! time with varying degrees of precision and accuracy. It does not //! depend on libc, but will use functions from it if available. const S = struct { //! Top level comments are allowed inside a container other than a module, //! but it is not very useful. Currently, when producing the package //! documentation, these comments are ignored. }; const std = @import("std"); pub fn main() !void { const stdout = std.io.getStdOut().writer(); try stdout.print("Hello, {s}!\n", .{"world"}); } // Top-level declarations are order-independent: const print = std.debug.print; const std = @import("std"); const os = std.os; const assert = std.debug.assert; pub fn main() void { // integers const one_plus_one: i32 = 1 + 1; print("1 + 1 = {}\n", .{one_plus_one}); // floats const seven_div_three: f32 = 7.0 / 3.0; print("7.0 / 3.0 = {}\n", .{seven_div_three}); // boolean print("{}\n{}\n{}\n", .{ true and false, true or false, !true, }); // optional var optional_value: ?[]const u8 = null; assert(optional_value == null); print("\noptional 1\ntype: {}\nvalue: {?s}\n", .{ @TypeOf(optional_value), optional_value, }); optional_value = "hi"; assert(optional_value != null); print("\noptional 2\ntype: {}\nvalue: {?s}\n", .{ @TypeOf(optional_value), optional_value, }); // error union var number_or_error: anyerror!i32 = error.ArgNotFound; print("\nerror union 1\ntype: {}\nvalue: {!}\n", .{ @TypeOf(number_or_error), number_or_error, }); number_or_error = 1234; print("\nerror union 2\ntype: {}\nvalue: {!}\n", .{ @TypeOf(number_or_error), number_or_error, }); } const print = @import("std").debug.print; const mem = @import("std").mem; // will be used to compare bytes pub fn main() void { const bytes = "hello\u{12345678}"; print("{}\n", .{@TypeOf(bytes)}); // *const [5:0]u8 print("{d}\n", .{bytes.len}); // 5 print("{c}\n", .{bytes[1]}); // 'e' print("{d}\n", .{bytes[5]}); // 0 print("{}\n", .{'e' == '\x65'}); // true print("{d}\n", .{'\u{1f4a9}'}); // 128169 print("{d}\n", .{'💯'}); // 128175 print("{u}\n", .{'âš¡'}); print("{}\n", .{mem.eql(u8, "hello", "h\x65llo")}); // true print("{}\n", .{mem.eql(u8, "💯", "\xf0\x9f\x92\xaf")}); // also true const invalid_utf8 = "\xff\xfe"; // non-UTF-8 strings are possible with \xNN notation. print("0x{x}\n", .{invalid_utf8[1]}); // indexing them returns individual bytes... print("0x{x}\n", .{"💯"[1]}); // ...as does indexing part-way through non-ASCII characters } const hello_world_in_c = \\#include \\ \\int main(int argc, char **argv) { \\ printf("hello world\n"); \\ return 0; \\} ; const std = @import("std"); const assert = std.debug.assert; threadlocal var x: i32 = 1234; test "thread local storage" { const thread1 = try std.Thread.spawn(.{}, testTls, .{}); const thread2 = try std.Thread.spawn(.{}, testTls, .{}); testTls(); thread1.join(); thread2.join(); } fn testTls() void { assert(x == 1234); x += 1; assert(x == 1235); } const decimal_int = 98222; const hex_int = 0xff; const another_hex_int = 0xFF; const octal_int = 0o755; const binary_int = 0b11110000; // underscores may be placed between two digits as a visual separator const one_billion = 1_000_000_000; const binary_mask = 0b1_1111_1111; const permissions = 0o7_5_5; const big_address = 0xFF80_0000_0000_0000; const floating_point = 123.0E+77; const another_float = 123.0; const yet_another = 123.0e+77; const hex_floating_point = 0x103.70p-5; const another_hex_float = 0x103.70; const yet_another_hex_float = 0x103.70P-5; // underscores may be placed between two digits as a visual separator const lightspeed = 299_792_458.000_000; const nanosecond = 0.000_000_001; const more_hex = 0x1234_5678.9ABC_CDEFp-10; const Vec3 = struct { x: f32, y: f32, z: f32, pub fn init(x: f32, y: f32, z: f32) Vec3 { return Vec3{ .x = x, .y = y, .z = z, }; } pub fn dot(self: Vec3, other: Vec3) f32 { return self.x * other.x + self.y * other.y + self.z * other.z; } }; fn LinkedList(comptime T: type) type { return struct { pub const Node = struct { prev: ?*Node, next: ?*Node, data: T, }; first: ?*Node, last: ?*Node, len: usize, }; } const Point = struct { x: f32, y: f32, }; // Maybe we want to pass it to OpenGL so we want to be particular about // how the bytes are arranged. const Point2 = packed struct { x: f32, y: f32, }; const std = @import("std"); const expect = std.testing.expect; const Color = enum { auto, off, on, }; const std = @import("std"); const builtin = @import("builtin"); const expect = std.testing.expect; test "switch simple" { const a: u64 = 10; const zz: u64 = 103; // All branches of a switch expression must be able to be coerced to a // common type. // // Branches cannot fallthrough. If fallthrough behavior is desired, combine // the cases and use an if. const b = switch (a) { // Multiple cases can be combined via a ',' 1, 2, 3 => 0, // Ranges can be specified using the ... syntax. These are inclusive // of both ends. 5...100 => 1, // Branches can be arbitrarily complex. 101 => blk: { const c: u64 = 5; break :blk c * 2 + 1; }, // Switching on arbitrary expressions is allowed as long as the // expression is known at compile-time. zz => zz, blk: { const d: u32 = 5; const e: u32 = 100; break :blk d + e; } => 107, // The else branch catches everything not already captured. // Else branches are mandatory unless the entire range of values // is handled. else => 9, }; try expect(b == 1); } fn charToDigit(c: u8) u8 { return switch (c) { '0'...'9' => c - '0', 'A'...'Z' => c - 'A' + 10, 'a'...'z' => c - 'a' + 10, else => maxInt(u8), }; } const optional_value: ?i32 = null; //! This module provides functions for retrieving the current date and //! time with varying degrees of precision and accuracy. It does not //! depend on libc, but will use functions from it if available. const @"identifier with spaces in it" = 0xff; const @"1SmallStep4Man" = 112358; const c = @import("std").c; pub extern "c" fn @"error"() void; pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int; const Color = enum { red, @"really red", }; const color: Color = .@"really red"; tmpok_q575y/lexilla/test/examples/json/0000775000175000017500000000000014773064066017751 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/json/SciTE.properties0000664000175000017500000000043114773064066023034 0ustar gusnangusnanlexer.*.json=json # JSON keywords keywords.*.json=false true null # JSON-LD keywords keywords2.*.json=@id @context @type @value @language @container \ @list @set @reverse @index @base @vocab @graph lexer.json.escape.sequence=1 lexer.json.allow.comments=1 fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/json/AllStyles.json.folded0000664000175000017500000000164714773064066024024 0ustar gusnangusnan 0 400 400 // Enumerate all styles: 0 to 13 1 400 400 0 400 400 // default=0 1 400 400 1 400 400 0 400 400 // number=1 0 400 400 1 1 400 400 0 400 400 // string=2 0 400 400 "2" 1 400 400 0 400 400 // stringeol=3 0 400 400 "3 1 400 400 0 400 400 // propertyname=4 0 400 400 "4": 1 400 400 0 400 400 // escapesequence=5 0 400 400 "\n" 1 400 400 0 400 400 // linecomment=6 0 400 400 // 6 Line Comment 1 400 400 0 400 400 // blockcomment=7 0 400 400 /* 7 Block Comment */ 1 400 400 0 400 400 // operator=8 0 400 400 {} 1 400 400 0 400 400 // uri=9 0 400 400 "http://9.org" 1 400 400 0 400 400 // compactiri=10 0 400 400 "x:y" 1 400 400 0 400 400 // keyword=11 0 400 400 true 1 400 400 0 400 400 // ldkeyword=12 0 400 400 "@id" 1 400 400 0 400 400 // error=13 0 400 400 # 13 error 0 400 0 tmpok_q575y/lexilla/test/examples/json/AllStyles.json.styled0000664000175000017500000000105414773064066024063 0ustar gusnangusnan{6}// Enumerate all styles: 0 to 13{0} {6}// default=0{0} {6}// number=1{0} {1}1{0} {6}// string=2{0} {2}"2"{0} {6}// stringeol=3{0} {3}"3 {0} {6}// propertyname=4{0} {4}"4"{8}:{0} {6}// escapesequence=5{0} {2}"{5}\n{2}"{0} {6}// linecomment=6{0} {6}// 6 Line Comment{0} {6}// blockcomment=7{0} {7}/* 7 Block Comment */{0} {6}// operator=8{0} {8}{}{0} {6}// uri=9{0} {2}"{9}http://9.org{2}"{0} {6}// compactiri=10{0} {10}"x:y"{0} {6}// keyword=11{0} {11}true{0} {6}// ldkeyword=12{0} {2}"{12}@id{2}"{0} {6}// error=13{0} {13}# 13 error{0} tmpok_q575y/lexilla/test/examples/json/AllStyles.json0000664000175000017500000000055314773064066022563 0ustar gusnangusnan// Enumerate all styles: 0 to 13 // default=0 // number=1 1 // string=2 "2" // stringeol=3 "3 // propertyname=4 "4": // escapesequence=5 "\n" // linecomment=6 // 6 Line Comment // blockcomment=7 /* 7 Block Comment */ // operator=8 {} // uri=9 "http://9.org" // compactiri=10 "x:y" // keyword=11 true // ldkeyword=12 "@id" // error=13 # 13 error tmpok_q575y/lexilla/test/examples/asm/0000775000175000017500000000000014773064066017560 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/asm/AllStyles.asm.folded0000664000175000017500000000245614773064066023441 0ustar gusnangusnan 0 400 0 ; Enumerate all styles: 0 to 15 except for 11(comment block) which is not yet implemented. 0 400 0 ; This is not a viable source file, it just illustrates the different states in isolation. 0 400 0 0 400 0 ; comment=1 0 400 0 ; Comment 0 400 0 0 400 0 ; whitespace=0 0 400 0 ; w 0 400 0 0 400 0 ; number=2 0 400 0 11 0 400 0 0 400 0 ; string=3 0 400 0 "String" 0 400 0 0 400 0 ; operator=4 0 400 0 + 0 400 0 0 400 0 ; identifier=5 0 400 0 identifier 0 400 0 0 400 0 ; CPU instruction=6 0 400 0 add 0 400 0 0 400 0 ; math Instruction=7 0 400 0 fadd 0 400 0 0 400 0 ; register=8 0 400 0 ECX 0 400 0 0 400 0 ; directive=9 0 400 0 section 0 400 0 0 400 0 ; directive operand=10 0 400 0 rel 0 400 0 0 400 0 ; comment block=11 is for future expansion 0 400 0 0 400 0 ; character=12 0 400 0 'character' 0 400 0 0 400 0 ; string EOL=13 0 400 0 "no line end 0 400 0 0 400 0 ; extended instruction=14 0 400 0 movq 0 400 0 0 400 0 ; comment directive=15 0 400 0 comment ~ A multiple-line 0 400 0 comment directive~ 0 400 0 0 400 0 ;end 0 400 0 tmpok_q575y/lexilla/test/examples/asm/AllStyles.asm0000664000175000017500000000117514773064066022202 0ustar gusnangusnan; Enumerate all styles: 0 to 15 except for 11(comment block) which is not yet implemented. ; This is not a viable source file, it just illustrates the different states in isolation. ; comment=1 ; Comment ; whitespace=0 ; w ; number=2 11 ; string=3 "String" ; operator=4 + ; identifier=5 identifier ; CPU instruction=6 add ; math Instruction=7 fadd ; register=8 ECX ; directive=9 section ; directive operand=10 rel ; comment block=11 is for future expansion ; character=12 'character' ; string EOL=13 "no line end ; extended instruction=14 movq ; comment directive=15 comment ~ A multiple-line comment directive~ ;end tmpok_q575y/lexilla/test/examples/asm/SciTE.properties0000664000175000017500000000041514773064066022645 0ustar gusnangusnanlexer.*.asm=asm keywords.*.asm=add sub xor mov lea call keywords2.*.asm=fadd keywords3.*.asm=rsp rax rcx rdx r8 r9 ecx keywords4.*.asm=db section alignb resq resqdb global extern equ .bss .text .data start comment keywords5.*.asm=qword rel keywords6.*.asm=movd movq tmpok_q575y/lexilla/test/examples/asm/AllStyles.asm.styled0000664000175000017500000000144114773064066023501 0ustar gusnangusnan{1}; Enumerate all styles: 0 to 15 except for 11(comment block) which is not yet implemented. ; This is not a viable source file, it just illustrates the different states in isolation. {0} {1}; comment=1 ; Comment {0} {1}; whitespace=0 {0} {1}; w {0} {1}; number=2 {2}11{0} {1}; string=3 {3}"String"{0} {1}; operator=4 {4}+{0} {1}; identifier=5 {5}identifier{0} {1}; CPU instruction=6 {6}add{0} {1}; math Instruction=7 {7}fadd{0} {1}; register=8 {8}ECX{0} {1}; directive=9 {9}section{0} {1}; directive operand=10 {10}rel{0} {1}; comment block=11 is for future expansion {0} {1}; character=12 {12}'character'{0} {1}; string EOL=13 {13}"no line end {0} {1}; extended instruction=14 {14}movq{0} {1}; comment directive=15 {0} {9}comment{0} {15}~ A multiple-line comment directive~{0} {1};end tmpok_q575y/lexilla/test/examples/markdown/0000775000175000017500000000000014773064066020622 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/markdown/Bug1216.md.styled0000664000175000017500000000111314773064066023472 0ustar gusnangusnan{6}#{0} Checking resolution of bug 1216{1} {0}*This line is not emphasized{1} {0}This is plain text with {4}*inline emphasis*{1} {0}_This, too, is not emphasized{1} {0}And this is plain text with {5}_inline emphasis_{1} {0}**This line is not in bold{1} {0}But this is plain text with some words {2}**in bold**{1} {0}__This line is also not in bold{1} {0}And this is plain text with {3}__some words in bold__{1} {0}~~This line is not crossed out{1} {0}This is plain text with {16}~~some words crossed out~~{1} {21}~~~ this is a code block ~~~{1} {0}This is a new paragraph{1} tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_0.md.styled0000664000175000017500000000031614773064066025225 0ustar gusnangusnan{0}H1{1} {6}=={1} {0}H2{1} {7}--{1} {6}#{0} H1{1} {7}##{0} H2{1} {0}H1{1} {6}=={1} {0}H2{1} {7}--{1} {6}#{0} H1{1} {7}##{0} H2{1} {8}###{0} H3{1} {9}####{0} H4{1} {10}#####{0} H5{1} {11}######{0} H6{1} tmpok_q575y/lexilla/test/examples/markdown/Issue117.md.styled0000664000175000017500000000044514773064066023773 0ustar gusnangusnan{0}The number:{1} {0}338269006135764734700913562171{1} {0}is prime. Therefore:{1} {12} {14}1.{0} the only factors of 338269006135764734700913562171 are:{1} {12} {0} 1{1} {12} {0} 338269006135764734700913562171{1} {12} {14}2.{0} 338269006135764734700913562171 is a natural number{1} tmpok_q575y/lexilla/test/examples/markdown/AllStyles.md.folded0000664000175000017500000000161014773064066024312 0ustar gusnangusnan 0 400 0 Text=0 0 400 0 Line end characters=1 0 400 0 **Strong Emphasis (bold) 1=2** 0 400 0 __Strong Emphasis (bold) 2=3__ 0 400 0 *Emphasis (italic) 1=4* 0 400 0 _Emphasis (italic) 2=5_ 0 400 0 # Heading level 1=6 0 400 0 ## Heading level 2=7 0 400 0 ### Heading level 3=8 0 400 0 #### Heading level 4=9 0 400 0 ##### Heading level 5=10 0 400 0 ###### Heading level 6=11 0 400 0 PreChar=12 0 400 0 * Unordered list item=13 0 400 0 1. Ordered list item=14 0 400 0 >Block Quote=15 0 400 0 ~~Strike-out=16~~ 0 400 0 0 400 0 *** 0 400 0 Previous line was horizontal rule=17 0 400 0 [Link=18](https://18.com) 0 400 0 `Inline Code=19` 0 400 0 ``Inline Code=20`` 0 400 0 0 400 0 ~~~ 0 400 0 Block code=21 0 400 0 ~~~ 0 400 0 0 400 0 ## Issue 23 0 400 0 `tmpok_q575y/lexilla/test/examples/markdown/Bug1216.md.folded0000664000175000017500000000152514773064066023432 0ustar gusnangusnan 0 400 0 # Checking resolution of bug 1216 0 400 0 0 400 0 *This line is not emphasized 0 400 0 0 400 0 This is plain text with *inline emphasis* 0 400 0 0 400 0 _This, too, is not emphasized 0 400 0 0 400 0 And this is plain text with _inline emphasis_ 0 400 0 0 400 0 **This line is not in bold 0 400 0 0 400 0 But this is plain text with some words **in bold** 0 400 0 0 400 0 __This line is also not in bold 0 400 0 0 400 0 And this is plain text with __some words in bold__ 0 400 0 0 400 0 ~~This line is not crossed out 0 400 0 0 400 0 This is plain text with ~~some words crossed out~~ 0 400 0 0 400 0 ~~~ 0 400 0 this is a code block 0 400 0 ~~~ 0 400 0 0 400 0 This is a new paragraph 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/SciTE.properties0000664000175000017500000000041214773064066023704 0ustar gusnangusnancode.page=65001 lexer.*.md=markdown fold=1 # Tests for the lexer.markdown.header.eolfill property, issue #62 if $(= $(FileNameExt);HeaderEOLFill_0.md) lexer.markdown.header.eolfill=0 if $(= $(FileNameExt);HeaderEOLFill_1.md) lexer.markdown.header.eolfill=1 tmpok_q575y/lexilla/test/examples/markdown/Bug2235.md0000664000175000017500000000111114773064066022167 0ustar gusnangusnanPo spuÅ¡tÄ›ní modulu je zobrazen hlavní dialog modulu: ![](media\image21.png)V tomto dialogu lze nastavit různé parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu případů ponechat pÅ™ednastavené hodnoty. Základní parametry ne nacházejí v záložce *Obecné*: ![SciTE224.png][]V tomto dialogu lze nastavit různé parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu případů ponechat pÅ™ednastavené hodnoty. Základní parametry ne nacházejí v záložce _Obecné_ [SciTE224.png]: https://www.scintilla.org/SciTE224.png tmpok_q575y/lexilla/test/examples/markdown/Issue117.md0000664000175000017500000000034314773064066022465 0ustar gusnangusnanThe number: 338269006135764734700913562171 is prime. Therefore: 1. the only factors of 338269006135764734700913562171 are: 1 338269006135764734700913562171 2. 338269006135764734700913562171 is a natural number tmpok_q575y/lexilla/test/examples/markdown/AllStyles.md0000664000175000017500000000100214773064066023051 0ustar gusnangusnanText=0 Line end characters=1 **Strong Emphasis (bold) 1=2** __Strong Emphasis (bold) 2=3__ *Emphasis (italic) 1=4* _Emphasis (italic) 2=5_ # Heading level 1=6 ## Heading level 2=7 ### Heading level 3=8 #### Heading level 4=9 ##### Heading level 5=10 ###### Heading level 6=11 PreChar=12 * Unordered list item=13 1. Ordered list item=14 >Block Quote=15 ~~Strike-out=16~~ *** Previous line was horizontal rule=17 [Link=18](https://18.com) `Inline Code=19` ``Inline Code=20`` ~~~ Block code=21 ~~~ ## Issue 23 `tmpok_q575y/lexilla/test/examples/markdown/Bug2247.md.folded0000664000175000017500000000144314773064066023436 0ustar gusnangusnan 0 400 0 # Checking resolution of bug 2247 0 400 0 0 400 0 ~~~sql 0 400 0 SELECT datetime() AS `date`; 0 400 0 ~~~ 0 400 0 0 400 0 ```sql 0 400 0 SELECT datetime() AS `date`; 0 400 0 ``` 0 400 0 0 400 0 List of examples: 0 400 0 0 400 0 - example *one* 0 400 0 0 400 0 - example _two_ 0 400 0 0 400 0 - example `inline code without end 0 400 0 0 400 0 In case of **AAA**: 0 400 0 0 400 0 ```sql 0 400 0 SELECT strftime('%Y-%m-%d %H:%M:%S', 'now') AS `date`; 0 400 0 ``` 0 400 0 0 400 0 or, in case of __BBB__: 0 400 0 . . . 0 400 0 0 400 0 - example *three* 0 400 0 0 400 0 Last paragraph. 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_0.md0000664000175000017500000000012414773064066023717 0ustar gusnangusnanH1 == H2 -- # H1 ## H2 H1 == H2 -- # H1 ## H2 ### H3 #### H4 ##### H5 ###### H6 tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_0.md.folded0000664000175000017500000000054514773064066025162 0ustar gusnangusnan 0 400 0 H1 0 400 0 == 0 400 0 0 400 0 H2 0 400 0 -- 0 400 0 0 400 0 # H1 0 400 0 0 400 0 ## H2 0 400 0 0 400 0 H1 0 400 0 == 0 400 0 H2 0 400 0 -- 0 400 0 # H1 0 400 0 ## H2 0 400 0 ### H3 0 400 0 #### H4 0 400 0 ##### H5 0 400 0 ###### H6 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/Issue117.md.folded0000664000175000017500000000061414773064066023722 0ustar gusnangusnan 0 400 0 The number: 0 400 0 0 400 0 338269006135764734700913562171 0 400 0 0 400 0 is prime. Therefore: 0 400 0 0 400 0 1. the only factors of 338269006135764734700913562171 are: 0 400 0 0 400 0 1 0 400 0 338269006135764734700913562171 0 400 0 0 400 0 2. 338269006135764734700913562171 is a natural number 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_1.md.folded0000664000175000017500000000054514773064066025163 0ustar gusnangusnan 0 400 0 H1 0 400 0 == 0 400 0 0 400 0 H2 0 400 0 -- 0 400 0 0 400 0 # H1 0 400 0 0 400 0 ## H2 0 400 0 0 400 0 H1 0 400 0 == 0 400 0 H2 0 400 0 -- 0 400 0 # H1 0 400 0 ## H2 0 400 0 ### H3 0 400 0 #### H4 0 400 0 ##### H5 0 400 0 ###### H6 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/Bug1216.md0000664000175000017500000000075114773064066022176 0ustar gusnangusnan# Checking resolution of bug 1216 *This line is not emphasized This is plain text with *inline emphasis* _This, too, is not emphasized And this is plain text with _inline emphasis_ **This line is not in bold But this is plain text with some words **in bold** __This line is also not in bold And this is plain text with __some words in bold__ ~~This line is not crossed out This is plain text with ~~some words crossed out~~ ~~~ this is a code block ~~~ This is a new paragraph tmpok_q575y/lexilla/test/examples/markdown/Bug2247.md0000664000175000017500000000062014773064066022176 0ustar gusnangusnan# Checking resolution of bug 2247 ~~~sql SELECT datetime() AS `date`; ~~~ ```sql SELECT datetime() AS `date`; ``` List of examples: - example *one* - example _two_ - example `inline code without end In case of **AAA**: ```sql SELECT strftime('%Y-%m-%d %H:%M:%S', 'now') AS `date`; ``` or, in case of __BBB__: . . . - example *three* Last paragraph. tmpok_q575y/lexilla/test/examples/markdown/AllStyles.md.styled0000664000175000017500000000130214773064066024357 0ustar gusnangusnan{0}Text=0{1} {0}Line end characters=1{1} {2}**Strong Emphasis (bold) 1=2**{1} {3}__Strong Emphasis (bold) 2=3__{1} {4}*Emphasis (italic) 1=4*{1} {5}_Emphasis (italic) 2=5_{1} {6}#{0} Heading level 1=6{1} {7}##{0} Heading level 2=7{1} {8}###{0} Heading level 3=8{1} {9}####{0} Heading level 4=9{1} {10}#####{0} Heading level 5=10{1} {11}######{0} Heading level 6=11{1} {12} {0}PreChar=12{1} {13}*{0} Unordered list item=13{1} {14}1.{0} Ordered list item=14{1} {15}>{0}Block Quote=15{1} {16}~~Strike-out=16~~{1} {17}***{1} {0}Previous line was horizontal rule=17{1} {18}[Link=18](https://18.com){1} {19}`Inline Code=19`{1} {20}``Inline Code=20``{1} {21}~~~ Block code=21 ~~~{1} {7}##{0} Issue 23{1} {0}`tmpok_q575y/lexilla/test/examples/markdown/Bug2235.md.folded0000664000175000017500000000143114773064066023430 0ustar gusnangusnan 0 400 0 Po spuÅ¡tÄ›ní modulu je zobrazen hlavní dialog modulu: 0 400 0 0 400 0 ![](media\image21.png)V tomto dialogu lze nastavit různé 0 400 0 parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu 0 400 0 případů ponechat pÅ™ednastavené hodnoty. 0 400 0 0 400 0 Základní parametry ne nacházejí v záložce *Obecné*: 0 400 0 0 400 0 ![SciTE224.png][]V tomto dialogu lze nastavit různé 0 400 0 parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu 0 400 0 případů ponechat pÅ™ednastavené hodnoty. 0 400 0 0 400 0 Základní parametry ne nacházejí v záložce _Obecné_ 0 400 0 0 400 0 [SciTE224.png]: https://www.scintilla.org/SciTE224.png 0 400 0 tmpok_q575y/lexilla/test/examples/markdown/Bug2247.md.styled0000664000175000017500000000106014773064066023500 0ustar gusnangusnan{6}#{0} Checking resolution of bug 2247{1} {21}~~~sql SELECT datetime() AS `date`; ~~~{1} {20}```sql SELECT datetime() AS `date`; ```{1} {0}List of examples:{1} {13}-{0} example {4}*one*{1} {13}-{0} example {5}_two_{1} {13}-{0} example `inline code without end{1} {12} {0} In case of {2}**AAA**{0}:{1} {12} {0} {1} {12} {0} {20}```sql SELECT strftime('%Y-%m-%d %H:%M:%S', 'now') AS `date`; ```{1} {12} {0} {1} {12} {0} or, in case of {3}__BBB__{0}:{1} {12} {0} . . .{1} {13}-{0} example {4}*three*{1} {0}Last paragraph.{1} tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_1.md0000664000175000017500000000012414773064066023720 0ustar gusnangusnanH1 == H2 -- # H1 ## H2 H1 == H2 -- # H1 ## H2 ### H3 #### H4 ##### H5 ###### H6 tmpok_q575y/lexilla/test/examples/markdown/HeaderEOLFill_1.md.styled0000664000175000017500000000023614773064066025227 0ustar gusnangusnan{0}H1{1} {6}== {1} {0}H2{1} {7}-- {1} {6}# H1 {1} {7}## H2 {1} {0}H1{1} {6}== {0}H2{1} {7}-- {6}# H1 {7}## H2 {8}### H3 {9}#### H4 {10}##### H5 {11}###### H6 tmpok_q575y/lexilla/test/examples/markdown/Bug2235.md.styled0000664000175000017500000000123214773064066023476 0ustar gusnangusnan{0}Po spuÅ¡tÄ›ní modulu je zobrazen hlavní dialog modulu:{1} {18}![](media\image21.png){0}V tomto dialogu lze nastavit různé{1} {0}parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu{1} {0}případů ponechat pÅ™ednastavené hodnoty.{1} {0}Základní parametry ne nacházejí v záložce {4}*Obecné*{0}:{1} {18}![SciTE224.png][]{0}V tomto dialogu lze nastavit různé{1} {0}parametry vykreslení výsledného schématu. DoporuÄujeme pro vÄ›tÅ¡inu{1} {0}případů ponechat pÅ™ednastavené hodnoty.{1} {0}Základní parametry ne nacházejí v záložce {5}_Obecné_{1} {18}[SciTE224.png]:{0} https://www.scintilla.org/SciTE224.png{1} tmpok_q575y/lexilla/test/examples/perl/0000775000175000017500000000000014773064066017742 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/perl/x.pl.styled0000664000175000017500000000025014773064066022046 0ustar gusnangusnan{5}use{0} {11}strict{10};{0} {5}while{0} {10}({0} {12}$r{0} {10}){0} {10}{{0} {5}printf{0} {10}({0} {6}"Example text \n"{0} {10});{0} {5}sleep{0} {4}1{10};{0} {10}}tmpok_q575y/lexilla/test/examples/perl/perl-test-5220delta.pl.folded0000664000175000017500000002013014773064066025046 0ustar gusnangusnan 2 400 401 + # -*- coding: utf-8 -*- 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5220delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod 0 401 401 | # maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod 0 401 401 | # also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22 0 401 401 | # 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # Kein-Hong Man Public Domain 20151217 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # 20151217 initial document 0 401 401 | # 20151218 updated tests and comments 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 use v5.22; # may be needed 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # New bitwise operators 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 use feature 'bitwise' # enable feature, warning enabled 0 400 400 use experimental "bitwise"; # enable feature, warning disabled 1 400 400 0 400 400 # numerical operands 0 400 400 10&20 10|20 10^20 ~10 0 400 400 $a&"8" $a|"8" $a^"8" ~$a ~"8" 1 400 400 0 400 400 # string operands 0 400 400 '0'&."8" '0'|."8" '0'^."8" ~.'0' ~."8" 2 400 401 + # the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled 0 401 400 | # so it's feature-setting-dependent, no plans to change current behaviour 0 400 400 $a&.10 $a|.10 $a^.10 ~.$a ~.10 1 400 400 0 400 400 # assignment variants 0 400 400 $a&=10; $a|=10; $a^=10; 0 400 400 $b&.='20'; $b|.='20'; $b^.='20'; 0 400 400 $c&="30"; $c|="30"; $c^="30"; 0 400 400 $d&.=$e; $d|.=$e; $d^.=$e; 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # New double-diamond operator 0 401 401 | #-------------------------------------------------------------------------- 0 401 400 | # <<>> is like <> but each element of @ARGV will be treated as an actual file name 1 400 400 0 400 400 # example snippet from brian d foy's blog post 2 400 401 + while( <<>> ) { # new, safe line input operator 0 401 401 | ...; 0 401 400 | } 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # New \b boundaries in regular expressions 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 qr/\b{gcb}/ 0 400 400 qr/\b{wb}/ 0 400 400 qr/\b{sb}/ 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # Non-Capturing Regular Expression Flag 0 401 401 | #-------------------------------------------------------------------------- 0 401 400 | # disables capturing and filling in $1, $2, etc 1 400 400 0 400 400 "hello" =~ /(hi|hello)/n; # $1 is not set 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # Aliasing via reference 0 401 401 | #-------------------------------------------------------------------------- 0 401 400 | # Variables and subroutines can now be aliased by assigning to a reference 1 400 400 0 400 400 \$c = \$d; 0 400 400 \&x = \&y; 1 400 400 0 400 400 # Aliasing can also be applied to foreach iterator variables 1 400 400 0 400 400 foreach \%hash (@array_of_hash_refs) { ... } 1 400 400 0 400 400 # example snippet from brian d foy's blog post 1 400 400 0 400 400 use feature qw(refaliasing); 1 400 400 0 400 400 \%other_hash = \%hash; 1 400 400 0 400 400 use v5.22; 0 400 400 use feature qw(refaliasing); 1 400 400 2 400 401 + foreach \my %hash ( @array_of_hashes ) { # named hash control variable 2 401 402 + foreach my $key ( keys %hash ) { # named hash now! 0 402 402 | ...; 0 402 401 | } 0 401 400 | } 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # New :const subroutine attribute 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 my $x = 54321; 0 400 400 *INLINED = sub : const { $x }; 0 400 400 $x++; 1 400 400 2 400 401 + # more examples of attributes 0 401 401 | # (not 5.22 stuff, but some general examples for study, useful for 0 401 400 | # handling subroutine signature and subroutine prototype highlighting) 1 400 400 0 400 400 sub foo : lvalue ; 1 400 400 2 400 401 + package X; 0 401 401 | sub Y::x : lvalue { 1 } 1 401 401 | 2 400 401 + package X; 0 401 401 | sub foo { 1 } 2 400 401 + package Y; 0 401 401 | BEGIN { *bar = \&X::foo; } 2 400 401 + package Z; 0 401 401 | sub Y::bar : lvalue ; 1 401 401 | 0 401 401 | # built-in attributes for subroutines: 0 401 401 | lvalue method prototype(..) locked const 1 401 401 | 2 401 402 + #-------------------------------------------------------------------------- 0 402 402 | # Repetition in list assignment 0 402 401 | #-------------------------------------------------------------------------- 1 401 401 | 0 401 401 | # example snippet from brian d foy's blog post 0 401 401 | use v5.22; 0 401 401 | my(undef, $card_num, (undef)x3, $count) = split /:/; 1 401 401 | 0 401 401 | (undef,undef,$foo) = that_function() 0 401 401 | # is equivalent to 0 401 401 | ((undef)x2, $foo) = that_function() 1 401 401 | 2 401 402 + #-------------------------------------------------------------------------- 0 402 402 | # Floating point parsing has been improved 0 402 402 | #-------------------------------------------------------------------------- 0 402 401 | # Hexadecimal floating point literals 1 401 401 | 2 401 402 + # some hex floats from a program by Rick Regan 0 402 402 | # appropriated and extended from Lua 5.2.x test cases 0 402 401 | # tested on perl 5.22/cygwin 1 401 401 | 0 401 401 | 0x1p-1074; 0 401 401 | 0x3.3333333333334p-5; 0 401 401 | 0xcc.ccccccccccdp-11; 0 401 401 | 0x1p+1; 0 401 401 | 0x1p-6; 0 401 401 | 0x1.b7p-1; 0 401 401 | 0x1.fffffffffffffp+1023; 0 401 401 | 0x1p-1022; 0 401 401 | 0X1.921FB4D12D84AP+1; 0 401 401 | 0x1.999999999999ap-4; 1 401 401 | 0 401 401 | # additional test cases for characterization 0 401 401 | 0x1p-1074. # dot is a string operator 0 401 401 | 0x.ABCDEFp10 # legal, dot immediately after 0x 0 401 401 | 0x.p10 # perl allows 0x as a zero, then concat with p10 bareword 0 401 401 | 0x.p 0x0.p # dot then bareword 0 401 401 | 0x_0_.A_BC___DEF_p1_0 # legal hex float, underscores are mostly allowed 0 401 401 | 0x0._ABCDEFp10 # _ABCDEFp10 is a bareword, no underscore allowed after dot 1 401 401 | 0 401 401 | # illegal, but does not use error highlighting 0 401 401 | 0x0p1ABC # illegal, highlighted as 0x0p1 abut with bareword ABC 1 401 401 | 0 401 401 | # allowed to FAIL for now 0 401 401 | 0x0.ABCDEFp_10 # ABCDEFp_10 is a bareword, '_10' exponent not allowed 0 401 401 | 0xp 0xp1 0x0.0p # syntax errors 0 401 401 | 0x41.65.65 # hex dot number, but lexer now fails with 0x41.65 left as a partial hex float 1 401 401 | 2 401 402 + #-------------------------------------------------------------------------- 0 402 402 | # Support for ?PATTERN? without explicit operator has been removed 0 402 402 | #-------------------------------------------------------------------------- 0 402 401 | # ?PATTERN? must now be written as m?PATTERN? 1 401 401 | 0 401 401 | ?PATTERN? # does not work in current LexPerl anyway, NO ACTION NEEDED 0 401 401 | m?PATTERN? 1 401 401 | 2 401 402 + #-------------------------------------------------------------------------- 0 402 402 | # end of test file 0 402 401 | #-------------------------------------------------------------------------- 0 401 0 | tmpok_q575y/lexilla/test/examples/perl/SciTE.properties0000664000175000017500000000344014773064066023030 0ustar gusnangusnanlexer.*.pl=perl keywords.*.pl=\ NULL __FILE__ __LINE__ __PACKAGE__ __DATA__ __END__ AUTOLOAD \ BEGIN CORE DESTROY END EQ GE GT INIT LE LT NE CHECK abs accept \ alarm and atan2 bind binmode bless caller chdir chmod chomp chop \ chown chr chroot close closedir cmp connect continue cos crypt \ dbmclose dbmopen defined delete die do dump each else elsif endgrent \ endhostent endnetent endprotoent endpwent endservent eof eq eval \ exec exists exit exp fcntl fileno flock for foreach fork format \ formline ge getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname \ gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername \ getpgrp getppid getpriority getprotobyname getprotobynumber getprotoent \ getpwent getpwnam getpwuid getservbyname getservbyport getservent \ getsockname getsockopt glob gmtime goto grep gt hex if index \ int ioctl join keys kill last lc lcfirst le length link listen \ local localtime lock log lstat lt map mkdir msgctl msgget msgrcv \ msgsnd my ne next no not oct open opendir or ord our pack package \ pipe pop pos print printf prototype push quotemeta qu \ rand read readdir readline readlink readpipe recv redo \ ref rename require reset return reverse rewinddir rindex rmdir \ scalar seek seekdir select semctl semget semop send setgrent \ sethostent setnetent setpgrp setpriority setprotoent setpwent \ setservent setsockopt shift shmctl shmget shmread shmwrite shutdown \ sin sleep socket socketpair sort splice split sprintf sqrt srand \ stat study sub substr symlink syscall sysopen sysread sysseek \ system syswrite tell telldir tie tied time times truncate \ uc ucfirst umask undef unless unlink unpack unshift untie until \ use utime values vec wait waitpid wantarray warn while write \ xor \ given when default break say state UNITCHECK __SUB__ fc fold=1 fold.comment=1tmpok_q575y/lexilla/test/examples/perl/x.pl.folded0000664000175000017500000000021014773064066021773 0ustar gusnangusnan 0 400 400 use strict; 2 400 401 + while ( $r ) { 0 401 401 | printf ( "Example text \n" ); 0 401 401 | sleep 1; 0 401 0 | }tmpok_q575y/lexilla/test/examples/perl/perl-test-sub-prototypes.pl0000664000175000017500000002124114773064066025233 0ustar gusnangusnan# -*- coding: utf-8 -*- #-------------------------------------------------------------------------- # perl-test-sub-prototypes.pl #-------------------------------------------------------------------------- # compiled all relevant subroutine prototype test cases # #-------------------------------------------------------------------------- # Kein-Hong Man Public Domain #-------------------------------------------------------------------------- # 20151227 initial document #-------------------------------------------------------------------------- #-------------------------------------------------------------------------- # test cases for sub syntax scanner #-------------------------------------------------------------------------- # sub syntax: simple and with added module notation #-------------------------------------------------------------------------- sub fish($) { 123; } sub fish::chips($) { 123; } # module syntax sub fish::chips::sauce($) { 123; } # multiple module syntax sub fish :: chips :: sauce ($) { 123; } # added whitespace sub fish :: # embedded comment chips # embedded comment :: sauce ($) { 123; } sub fish :: ($) { 123; } # incomplete or bad syntax examples sub fish :: 123 ($) { 123; } sub fish :: chips 123 ($) { 123; } sub 123 ($) { 123; } #-------------------------------------------------------------------------- # sub syntax: prototype attributes #-------------------------------------------------------------------------- sub fish:prototype($) { 123; } sub fish : prototype ($) { 123; } # added whitespace sub fish:salted($) { 123; } # wrong attribute example (must use 'prototype') sub fish : 123($) { 123; } # illegal attribute sub fish:prototype:salted($) { 123; } # wrong 'prototype' position sub fish:salted salt:prototype($) { 123; } # wrong attribute syntax sub fish:const:prototype($) { 123; } # extra attributes sub fish:const:lvalue:prototype($) { 123; } sub fish:const:prototype($):lvalue{ 123; } # might be legal too sub fish :const :prototype($) { 123; } # extra whitespace sub fish :const # embedded comment: a constant sub :prototype # embedded comment ($) { 123; } #-------------------------------------------------------------------------- # sub syntax: mixed #-------------------------------------------------------------------------- sub fish::chips:prototype($) { 123; } sub fish::chips::sauce:prototype($) { 123; } sub fish ::chips ::sauce :prototype($) { 123; } # +whitespace sub fish::chips::sauce:const:prototype($) { 123; } sub fish::chips::sauce :const :prototype($) { 123; } # +whitespace sub fish # embedded comment ::chips ::sauce # embedded comment : const # embedded comment : prototype ($) { 123; } # wrong syntax examples, parentheses must follow ':prototype' sub fish :prototype :const ($) { 123;} sub fish :prototype ::chips ($) { 123;} #-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # More consistent prototype parsing #-------------------------------------------------------------------------- # - whitespace now allowed, lexer now allows spaces or tabs sub foo ( $ $ ) {} sub foo ( ) {} # spaces/tabs empty sub foo ( * ) {} sub foo (@ ) {} sub foo ( %) {} # untested, should probably be \[ but scanner does not check this for now sub foo ( \ [ $ @ % & * ] ) {} #-------------------------------------------------------------------------- # perl-test-5140delta.pl #-------------------------------------------------------------------------- # new + prototype character, acts like (\[@%]) #-------------------------------------------------------------------------- # these samples work as before sub mylink ($$) # mylink $old, $new sub myvec ($$$) # myvec $var, $offset, 1 sub myindex ($$;$) # myindex &getstring, "substr" sub mysyswrite ($$$;$) # mysyswrite $buf, 0, length($buf) - $off, $off sub myreverse (@) # myreverse $a, $b, $c sub myjoin ($@) # myjoin ":", $a, $b, $c sub myopen (*;$) # myopen HANDLE, $name sub mypipe (**) # mypipe READHANDLE, WRITEHANDLE sub mygrep (&@) # mygrep { /foo/ } $a, $b, $c sub myrand (;$) # myrand 42 sub mytime () # mytime # backslash group notation to specify more than one allowed argument type sub myref (\[$@%&*]) {} sub mysub (_) # underscore can be optionally used FIXED 20151211 # these uses the new '+' prototype character sub mypop (+) # mypop @array sub mysplice (+$$@) # mysplice @array, 0, 2, @pushme sub mykeys (+) # mykeys %{$hashref} #-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # Experimental Subroutine signatures (mostly works) #-------------------------------------------------------------------------- # INCLUDED FOR COMPLETENESS ONLY # IMPORTANT NOTE the subroutine prototypes lexing implementation has # no effect on subroutine signature syntax highlighting # subroutine signatures mostly looks fine except for the @ and % slurpy # notation which are highlighted as operators (all other parameters are # highlighted as vars of some sort), a minor aesthetic issue use feature 'signatures'; sub foo ($left, $right) { # mandatory positional parameters return $left + $right; } sub foo ($first, $, $third) { # ignore second argument return "first=$first, third=$third"; } sub foo ($left, $right = 0) { # optional parameter with default value return $left + $right; } my $auto_id = 0; # default value expression, evaluated if default used only sub foo ($thing, $id = $auto_id++) { print "$thing has ID $id"; } sub foo ($first_name, $surname, $nickname = $first_name) { # 3rd parm may depend on 1st parm print "$first_name $surname is known as \"$nickname\""; } sub foo ($thing, $ = 1) { # nameless default parameter print $thing; } sub foo ($thing, $=) { # (this does something, I'm not sure what...) print $thing; } sub foo ($filter, @inputs) { # additional arguments (slurpy parameter) print $filter->($_) foreach @inputs; } sub foo ($thing, @) { # nameless slurpy parameter FAILS for now print $thing; } sub foo ($filter, %inputs) { # slurpy parameter, hash type print $filter->($_, $inputs{$_}) foreach sort keys %inputs; } sub foo ($thing, %) { # nameless slurpy parm, hash type FAILS for now print $thing; } sub foo () { # empty signature no arguments (styled as prototype) return 123; } #-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # subs now take a prototype attribute #-------------------------------------------------------------------------- sub foo :prototype($) { $_[0] } sub foo :prototype($$) ($left, $right) { return $left + $right; } sub foo : prototype($$){} # whitespace allowed # additional samples from perl-test-cases.pl with ':prototype' added: sub mylink :prototype($$) {} sub myvec :prototype($$$) {} sub myindex :prototype($$;$) {} sub mysyswrite :prototype($$$;$) {} sub myreverse :prototype(@) {} sub myjoin :prototype($@) {} sub mypop :prototype(\@) {} sub mysplice :prototype(\@$$@) {} sub mykeys :prototype(\%) {} sub myopen :prototype(*;$) {} sub mypipe :prototype(**) {} sub mygrep :prototype(&@) {} sub myrand :prototype($) {} sub mytime :prototype() {} # backslash group notation to specify more than one allowed argument type sub myref :prototype(\[$@%&*]) {} # additional attributes may complicate scanning for prototype syntax, # for example (from https://metacpan.org/pod/perlsub): # Lvalue subroutines my $val; sub canmod : lvalue { $val; # or: return $val; } canmod() = 5; # assigns to $val #-------------------------------------------------------------------------- # perl-test-5220delta.pl #-------------------------------------------------------------------------- # New :const subroutine attribute #-------------------------------------------------------------------------- my $x = 54321; *INLINED = sub : const { $x }; $x++; # more examples of attributes # (not 5.22 stuff, but some general examples for study, useful for # handling subroutine signature and subroutine prototype highlighting) sub foo : lvalue ; package X; sub Y::z : lvalue { 1 } package X; sub foo { 1 } package Y; BEGIN { *bar = \&X::foo; } package Z; sub Y::bar : lvalue ; # built-in attributes for subroutines: lvalue method prototype(..) locked const #-------------------------------------------------------------------------- # end of test file #-------------------------------------------------------------------------- tmpok_q575y/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.folded0000664000175000017500000002732114773064066026474 0ustar gusnangusnan 2 400 401 + # -*- coding: utf-8 -*- 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # perl-test-sub-prototypes.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # compiled all relevant subroutine prototype test cases 0 401 401 | # 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # Kein-Hong Man Public Domain 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # 20151227 initial document 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # test cases for sub syntax scanner 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # sub syntax: simple and with added module notation 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 sub fish($) { 123; } 0 400 400 sub fish::chips($) { 123; } # module syntax 0 400 400 sub fish::chips::sauce($) { 123; } # multiple module syntax 1 400 400 0 400 400 sub fish :: chips :: sauce ($) { 123; } # added whitespace 1 400 400 0 400 400 sub fish :: # embedded comment 0 400 400 chips # embedded comment 0 400 400 :: sauce ($) { 123; } 1 400 400 0 400 400 sub fish :: ($) { 123; } # incomplete or bad syntax examples 0 400 400 sub fish :: 123 ($) { 123; } 0 400 400 sub fish :: chips 123 ($) { 123; } 0 400 400 sub 123 ($) { 123; } 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # sub syntax: prototype attributes 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 sub fish:prototype($) { 123; } 0 400 400 sub fish : prototype ($) { 123; } # added whitespace 1 400 400 0 400 400 sub fish:salted($) { 123; } # wrong attribute example (must use 'prototype') 0 400 400 sub fish : 123($) { 123; } # illegal attribute 0 400 400 sub fish:prototype:salted($) { 123; } # wrong 'prototype' position 0 400 400 sub fish:salted salt:prototype($) { 123; } # wrong attribute syntax 1 400 400 0 400 400 sub fish:const:prototype($) { 123; } # extra attributes 0 400 400 sub fish:const:lvalue:prototype($) { 123; } 0 400 400 sub fish:const:prototype($):lvalue{ 123; } # might be legal too 0 400 400 sub fish :const :prototype($) { 123; } # extra whitespace 1 400 400 0 400 400 sub fish :const # embedded comment: a constant sub 0 400 400 :prototype # embedded comment 0 400 400 ($) { 123; } 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # sub syntax: mixed 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 sub fish::chips:prototype($) { 123; } 0 400 400 sub fish::chips::sauce:prototype($) { 123; } 0 400 400 sub fish ::chips ::sauce :prototype($) { 123; } # +whitespace 1 400 400 0 400 400 sub fish::chips::sauce:const:prototype($) { 123; } 0 400 400 sub fish::chips::sauce :const :prototype($) { 123; } # +whitespace 1 400 400 0 400 400 sub fish # embedded comment 0 400 400 ::chips ::sauce # embedded comment 0 400 400 : const # embedded comment 0 400 400 : prototype ($) { 123; } 1 400 400 0 400 400 # wrong syntax examples, parentheses must follow ':prototype' 0 400 400 sub fish :prototype :const ($) { 123;} 0 400 400 sub fish :prototype ::chips ($) { 123;} 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5200delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # More consistent prototype parsing 0 401 401 | #-------------------------------------------------------------------------- 0 401 400 | # - whitespace now allowed, lexer now allows spaces or tabs 1 400 400 0 400 400 sub foo ( $ $ ) {} 0 400 400 sub foo ( ) {} # spaces/tabs empty 0 400 400 sub foo ( * ) {} 0 400 400 sub foo (@ ) {} 0 400 400 sub foo ( %) {} 1 400 400 0 400 400 # untested, should probably be \[ but scanner does not check this for now 0 400 400 sub foo ( \ [ $ @ % & * ] ) {} 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5140delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # new + prototype character, acts like (\[@%]) 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 # these samples work as before 0 400 400 sub mylink ($$) # mylink $old, $new 0 400 400 sub myvec ($$$) # myvec $var, $offset, 1 0 400 400 sub myindex ($$;$) # myindex &getstring, "substr" 0 400 400 sub mysyswrite ($$$;$) # mysyswrite $buf, 0, length($buf) - $off, $off 0 400 400 sub myreverse (@) # myreverse $a, $b, $c 0 400 400 sub myjoin ($@) # myjoin ":", $a, $b, $c 0 400 400 sub myopen (*;$) # myopen HANDLE, $name 0 400 400 sub mypipe (**) # mypipe READHANDLE, WRITEHANDLE 0 400 400 sub mygrep (&@) # mygrep { /foo/ } $a, $b, $c 0 400 400 sub myrand (;$) # myrand 42 0 400 400 sub mytime () # mytime 1 400 400 0 400 400 # backslash group notation to specify more than one allowed argument type 0 400 400 sub myref (\[$@%&*]) {} 1 400 400 0 400 400 sub mysub (_) # underscore can be optionally used FIXED 20151211 1 400 400 0 400 400 # these uses the new '+' prototype character 0 400 400 sub mypop (+) # mypop @array 0 400 400 sub mysplice (+$$@) # mysplice @array, 0, 2, @pushme 0 400 400 sub mykeys (+) # mykeys %{$hashref} 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5200delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # Experimental Subroutine signatures (mostly works) 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # INCLUDED FOR COMPLETENESS ONLY 0 401 401 | # IMPORTANT NOTE the subroutine prototypes lexing implementation has 0 401 400 | # no effect on subroutine signature syntax highlighting 1 400 400 2 400 401 + # subroutine signatures mostly looks fine except for the @ and % slurpy 0 401 401 | # notation which are highlighted as operators (all other parameters are 0 401 400 | # highlighted as vars of some sort), a minor aesthetic issue 1 400 400 0 400 400 use feature 'signatures'; 1 400 400 2 400 401 + sub foo ($left, $right) { # mandatory positional parameters 0 401 401 | return $left + $right; 0 401 400 | } 2 400 401 + sub foo ($first, $, $third) { # ignore second argument 0 401 401 | return "first=$first, third=$third"; 0 401 400 | } 2 400 401 + sub foo ($left, $right = 0) { # optional parameter with default value 0 401 401 | return $left + $right; 0 401 400 | } 0 400 400 my $auto_id = 0; # default value expression, evaluated if default used only 2 400 401 + sub foo ($thing, $id = $auto_id++) { 0 401 401 | print "$thing has ID $id"; 0 401 400 | } 2 400 401 + sub foo ($first_name, $surname, $nickname = $first_name) { # 3rd parm may depend on 1st parm 0 401 401 | print "$first_name $surname is known as \"$nickname\""; 0 401 400 | } 2 400 401 + sub foo ($thing, $ = 1) { # nameless default parameter 0 401 401 | print $thing; 0 401 400 | } 2 400 401 + sub foo ($thing, $=) { # (this does something, I'm not sure what...) 0 401 401 | print $thing; 0 401 400 | } 2 400 401 + sub foo ($filter, @inputs) { # additional arguments (slurpy parameter) 0 401 401 | print $filter->($_) foreach @inputs; 0 401 400 | } 2 400 401 + sub foo ($thing, @) { # nameless slurpy parameter FAILS for now 0 401 401 | print $thing; 0 401 400 | } 2 400 401 + sub foo ($filter, %inputs) { # slurpy parameter, hash type 0 401 401 | print $filter->($_, $inputs{$_}) foreach sort keys %inputs; 0 401 400 | } 2 400 401 + sub foo ($thing, %) { # nameless slurpy parm, hash type FAILS for now 0 401 401 | print $thing; 0 401 400 | } 2 400 401 + sub foo () { # empty signature no arguments (styled as prototype) 0 401 401 | return 123; 0 401 400 | } 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5200delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # subs now take a prototype attribute 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 sub foo :prototype($) { $_[0] } 1 400 400 2 400 401 + sub foo :prototype($$) ($left, $right) { 0 401 401 | return $left + $right; 0 401 400 | } 1 400 400 0 400 400 sub foo : prototype($$){} # whitespace allowed 1 400 400 0 400 400 # additional samples from perl-test-cases.pl with ':prototype' added: 0 400 400 sub mylink :prototype($$) {} sub myvec :prototype($$$) {} 0 400 400 sub myindex :prototype($$;$) {} sub mysyswrite :prototype($$$;$) {} 0 400 400 sub myreverse :prototype(@) {} sub myjoin :prototype($@) {} 0 400 400 sub mypop :prototype(\@) {} sub mysplice :prototype(\@$$@) {} 0 400 400 sub mykeys :prototype(\%) {} sub myopen :prototype(*;$) {} 0 400 400 sub mypipe :prototype(**) {} sub mygrep :prototype(&@) {} 0 400 400 sub myrand :prototype($) {} sub mytime :prototype() {} 0 400 400 # backslash group notation to specify more than one allowed argument type 0 400 400 sub myref :prototype(\[$@%&*]) {} 1 400 400 2 400 401 + # additional attributes may complicate scanning for prototype syntax, 0 401 401 | # for example (from https://metacpan.org/pod/perlsub): 0 401 400 | # Lvalue subroutines 1 400 400 0 400 400 my $val; 2 400 401 + sub canmod : lvalue { 0 401 401 | $val; # or: return $val; 0 401 400 | } 0 400 400 canmod() = 5; # assigns to $val 1 400 400 2 400 401 + #-------------------------------------------------------------------------- 0 401 401 | # perl-test-5220delta.pl 0 401 401 | #-------------------------------------------------------------------------- 0 401 401 | # New :const subroutine attribute 0 401 400 | #-------------------------------------------------------------------------- 1 400 400 0 400 400 my $x = 54321; 0 400 400 *INLINED = sub : const { $x }; 0 400 400 $x++; 1 400 400 2 400 401 + # more examples of attributes 0 401 401 | # (not 5.22 stuff, but some general examples for study, useful for 0 401 400 | # handling subroutine signature and subroutine prototype highlighting) 1 400 400 0 400 400 sub foo : lvalue ; 1 400 400 2 400 401 + package X; 0 401 401 | sub Y::z : lvalue { 1 } 1 401 401 | 2 400 401 + package X; 0 401 401 | sub foo { 1 } 2 400 401 + package Y; 0 401 401 | BEGIN { *bar = \&X::foo; } 2 400 401 + package Z; 0 401 401 | sub Y::bar : lvalue ; 1 401 401 | 0 401 401 | # built-in attributes for subroutines: 0 401 401 | lvalue method prototype(..) locked const 1 401 401 | 2 401 402 + #-------------------------------------------------------------------------- 0 402 402 | # end of test file 0 402 401 | #-------------------------------------------------------------------------- 0 401 0 | tmpok_q575y/lexilla/test/examples/perl/x.pl0000664000175000017500000000010714773064066020544 0ustar gusnangusnanuse strict; while ( $r ) { printf ( "Example text \n" ); sleep 1; }tmpok_q575y/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.styled0000664000175000017500000003264514773064066026550 0ustar gusnangusnan{2}# -*- coding: utf-8 -*- #-------------------------------------------------------------------------- # perl-test-sub-prototypes.pl #-------------------------------------------------------------------------- # compiled all relevant subroutine prototype test cases # #-------------------------------------------------------------------------- # Kein-Hong Man Public Domain #-------------------------------------------------------------------------- # 20151227 initial document #-------------------------------------------------------------------------- {0} {2}#-------------------------------------------------------------------------- # test cases for sub syntax scanner #-------------------------------------------------------------------------- # sub syntax: simple and with added module notation #-------------------------------------------------------------------------- {0} {5}sub{0} {11}fish{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{10}::{11}chips{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# module syntax {5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# multiple module syntax {0} {5}sub{0} {11}fish{0} {10}::{0} {11}chips{0} {10}::{0} {11}sauce{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# added whitespace {0} {5}sub{0} {11}fish{0} {10}::{0} {2}# embedded comment {11}chips{0} {2}# embedded comment {0} {10}::{0} {11}sauce{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{0} {10}::{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# incomplete or bad syntax examples {5}sub{0} {11}fish{0} {10}::{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{0} {10}::{0} {11}chips{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}#-------------------------------------------------------------------------- # sub syntax: prototype attributes #-------------------------------------------------------------------------- {0} {5}sub{0} {11}fish{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{0} {10}:{0} {5}prototype{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# added whitespace {0} {5}sub{0} {11}fish{10}:{11}salted{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong attribute example (must use 'prototype') {5}sub{0} {11}fish{0} {10}:{0} {4}123{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# illegal attribute {5}sub{0} {11}fish{10}:{5}prototype{10}:{11}salted{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong 'prototype' position {5}sub{0} {11}fish{10}:{11}salted{0} {11}salt{10}:{5}prototype{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong attribute syntax {0} {5}sub{0} {11}fish{10}:{11}const{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# extra attributes {5}sub{0} {11}fish{10}:{11}const{10}:{11}lvalue{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{10}:{11}const{10}:{5}prototype{40}($){10}:{11}lvalue{10}{{0} {4}123{10};{0} {10}}{0} {2}# might be legal too {5}sub{0} {11}fish{0} {10}:{11}const{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# extra whitespace {0} {5}sub{0} {11}fish{0} {10}:{11}const{0} {2}# embedded comment: a constant sub {10}:{5}prototype{0} {2}# embedded comment {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}#-------------------------------------------------------------------------- # sub syntax: mixed #-------------------------------------------------------------------------- {0} {5}sub{0} {11}fish{10}::{11}chips{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{0} {10}::{11}chips{0} {10}::{11}sauce{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# +whitespace {0} {5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{10}:{11}const{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{0} {10}:{11}const{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# +whitespace {0} {5}sub{0} {11}fish{0} {2}# embedded comment {10}::{11}chips{0} {10}::{11}sauce{0} {2}# embedded comment {0} {10}:{0} {11}const{0} {2}# embedded comment {0} {10}:{0} {5}prototype{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong syntax examples, parentheses must follow ':prototype' {5}sub{0} {11}fish{0} {10}:{5}prototype{0} {10}:{11}const{0} {10}({12}$){0} {10}{{0} {4}123{10};}{0} {5}sub{0} {11}fish{0} {10}:{5}prototype{0} {10}::{11}chips{0} {10}({12}$){0} {10}{{0} {4}123{10};}{0} {2}#-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # More consistent prototype parsing #-------------------------------------------------------------------------- # - whitespace now allowed, lexer now allows spaces or tabs {0} {5}sub{0} {11}foo{0} {40}( $ $ ){0} {10}{}{0} {5}sub{0} {11}foo{0} {40}( ){0} {10}{}{0} {2}# spaces/tabs empty {5}sub{0} {11}foo{0} {40}( * ){0} {10}{}{0} {5}sub{0} {11}foo{0} {40}(@ ){0} {10}{}{0} {5}sub{0} {11}foo{0} {40}( %){0} {10}{}{0} {2}# untested, should probably be \[ but scanner does not check this for now {5}sub{0} {11}foo{0} {40}( \ [ $ @ % & * ] ){0} {10}{}{0} {2}#-------------------------------------------------------------------------- # perl-test-5140delta.pl #-------------------------------------------------------------------------- # new + prototype character, acts like (\[@%]) #-------------------------------------------------------------------------- {0} {2}# these samples work as before {5}sub{0} {11}mylink{0} {40}($$){0} {2}# mylink $old, $new {5}sub{0} {11}myvec{0} {40}($$$){0} {2}# myvec $var, $offset, 1 {5}sub{0} {11}myindex{0} {40}($$;$){0} {2}# myindex &getstring, "substr" {5}sub{0} {11}mysyswrite{0} {40}($$$;$){0} {2}# mysyswrite $buf, 0, length($buf) - $off, $off {5}sub{0} {11}myreverse{0} {40}(@){0} {2}# myreverse $a, $b, $c {5}sub{0} {11}myjoin{0} {40}($@){0} {2}# myjoin ":", $a, $b, $c {5}sub{0} {11}myopen{0} {40}(*;$){0} {2}# myopen HANDLE, $name {5}sub{0} {11}mypipe{0} {40}(**){0} {2}# mypipe READHANDLE, WRITEHANDLE {5}sub{0} {11}mygrep{0} {40}(&@){0} {2}# mygrep { /foo/ } $a, $b, $c {5}sub{0} {11}myrand{0} {40}(;$){0} {2}# myrand 42 {5}sub{0} {11}mytime{0} {40}(){0} {2}# mytime {0} {2}# backslash group notation to specify more than one allowed argument type {5}sub{0} {11}myref{0} {40}(\[$@%&*]){0} {10}{}{0} {5}sub{0} {11}mysub{0} {40}(_){0} {2}# underscore can be optionally used FIXED 20151211 {0} {2}# these uses the new '+' prototype character {5}sub{0} {11}mypop{0} {40}(+){0} {2}# mypop @array {5}sub{0} {11}mysplice{0} {40}(+$$@){0} {2}# mysplice @array, 0, 2, @pushme {5}sub{0} {11}mykeys{0} {40}(+){0} {2}# mykeys %{$hashref} {0} {2}#-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # Experimental Subroutine signatures (mostly works) #-------------------------------------------------------------------------- # INCLUDED FOR COMPLETENESS ONLY # IMPORTANT NOTE the subroutine prototypes lexing implementation has # no effect on subroutine signature syntax highlighting {0} {2}# subroutine signatures mostly looks fine except for the @ and % slurpy # notation which are highlighted as operators (all other parameters are # highlighted as vars of some sort), a minor aesthetic issue {0} {5}use{0} {11}feature{0} {7}'signatures'{10};{0} {5}sub{0} {11}foo{0} {10}({12}$left{10},{0} {12}$right{10}){0} {10}{{0} {2}# mandatory positional parameters {0} {5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$first{10},{0} {12}$,{0} {12}$third{10}){0} {10}{{0} {2}# ignore second argument {0} {5}return{0} {6}"first={43}$first{6}, third={43}$third{6}"{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$left{10},{0} {12}$right{0} {10}={0} {4}0{10}){0} {10}{{0} {2}# optional parameter with default value {0} {5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0} {10}}{0} {5}my{0} {12}$auto_id{0} {10}={0} {4}0{10};{0} {2}# default value expression, evaluated if default used only {5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}$id{0} {10}={0} {12}$auto_id{10}++){0} {10}{{0} {5}print{0} {6}"{43}$thing{6} has ID {43}$id{6}"{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$first_name{10},{0} {12}$surname{10},{0} {12}$nickname{0} {10}={0} {12}$first_name{10}){0} {10}{{0} {2}# 3rd parm may depend on 1st parm {0} {5}print{0} {6}"{43}$first_name{6} {43}$surname{6} is known as \"{43}$nickname{6}\""{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}${0} {10}={0} {4}1{10}){0} {10}{{0} {2}# nameless default parameter {0} {5}print{0} {12}$thing{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}$={10}){0} {10}{{0} {2}# (this does something, I'm not sure what...) {0} {5}print{0} {12}$thing{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$filter{10},{0} {13}@inputs{10}){0} {10}{{0} {2}# additional arguments (slurpy parameter) {0} {5}print{0} {12}$filter{10}->({12}$_{10}){0} {5}foreach{0} {13}@inputs{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {10}@){0} {10}{{0} {2}# nameless slurpy parameter FAILS for now {0} {5}print{0} {12}$thing{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$filter{10},{0} {14}%inputs{10}){0} {10}{{0} {2}# slurpy parameter, hash type {0} {5}print{0} {12}$filter{10}->({12}$_{10},{0} {12}$inputs{10}{{12}$_{10}}){0} {5}foreach{0} {5}sort{0} {5}keys{0} {14}%inputs{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {10}%){0} {10}{{0} {2}# nameless slurpy parm, hash type FAILS for now {0} {5}print{0} {12}$thing{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {40}(){0} {10}{{0} {2}# empty signature no arguments (styled as prototype) {0} {5}return{0} {4}123{10};{0} {10}}{0} {2}#-------------------------------------------------------------------------- # perl-test-5200delta.pl #-------------------------------------------------------------------------- # subs now take a prototype attribute #-------------------------------------------------------------------------- {0} {5}sub{0} {11}foo{0} {10}:{5}prototype{40}($){0} {10}{{0} {12}$_{10}[{4}0{10}]{0} {10}}{0} {5}sub{0} {11}foo{0} {10}:{5}prototype{40}($$){0} {10}({12}$left{10},{0} {12}$right{10}){0} {10}{{0} {5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0} {10}}{0} {5}sub{0} {11}foo{0} {10}:{0} {5}prototype{40}($$){10}{}{0} {2}# whitespace allowed {0} {2}# additional samples from perl-test-cases.pl with ':prototype' added: {5}sub{0} {11}mylink{0} {10}:{5}prototype{40}($$){0} {10}{}{0} {5}sub{0} {11}myvec{0} {10}:{5}prototype{40}($$$){0} {10}{}{0} {5}sub{0} {11}myindex{0} {10}:{5}prototype{40}($$;$){0} {10}{}{0} {5}sub{0} {11}mysyswrite{0} {10}:{5}prototype{40}($$$;$){0} {10}{}{0} {5}sub{0} {11}myreverse{0} {10}:{5}prototype{40}(@){0} {10}{}{0} {5}sub{0} {11}myjoin{0} {10}:{5}prototype{40}($@){0} {10}{}{0} {5}sub{0} {11}mypop{0} {10}:{5}prototype{40}(\@){0} {10}{}{0} {5}sub{0} {11}mysplice{0} {10}:{5}prototype{40}(\@$$@){0} {10}{}{0} {5}sub{0} {11}mykeys{0} {10}:{5}prototype{40}(\%){0} {10}{}{0} {5}sub{0} {11}myopen{0} {10}:{5}prototype{40}(*;$){0} {10}{}{0} {5}sub{0} {11}mypipe{0} {10}:{5}prototype{40}(**){0} {10}{}{0} {5}sub{0} {11}mygrep{0} {10}:{5}prototype{40}(&@){0} {10}{}{0} {5}sub{0} {11}myrand{0} {10}:{5}prototype{40}($){0} {10}{}{0} {5}sub{0} {11}mytime{0} {10}:{5}prototype{40}(){0} {10}{}{0} {2}# backslash group notation to specify more than one allowed argument type {5}sub{0} {11}myref{0} {10}:{5}prototype{40}(\[$@%&*]){0} {10}{}{0} {2}# additional attributes may complicate scanning for prototype syntax, # for example (from https://metacpan.org/pod/perlsub): # Lvalue subroutines {0} {5}my{0} {12}$val{10};{0} {5}sub{0} {11}canmod{0} {10}:{0} {11}lvalue{0} {10}{{0} {12}$val{10};{0} {2}# or: return $val; {10}}{0} {11}canmod{10}(){0} {10}={0} {4}5{10};{0} {2}# assigns to $val {0} {2}#-------------------------------------------------------------------------- # perl-test-5220delta.pl #-------------------------------------------------------------------------- # New :const subroutine attribute #-------------------------------------------------------------------------- {0} {5}my{0} {12}$x{0} {10}={0} {4}54321{10};{0} {15}*INLINED{0} {10}={0} {5}sub{0} {10}:{0} {11}const{0} {10}{{0} {12}$x{0} {10}};{0} {12}$x{10}++;{0} {2}# more examples of attributes # (not 5.22 stuff, but some general examples for study, useful for # handling subroutine signature and subroutine prototype highlighting) {0} {5}sub{0} {11}foo{0} {10}:{0} {11}lvalue{0} {10};{0} {5}package{0} {11}X{10};{0} {5}sub{0} {11}Y{10}::{11}z{0} {10}:{0} {11}lvalue{0} {10}{{0} {4}1{0} {10}}{0} {5}package{0} {11}X{10};{0} {5}sub{0} {11}foo{0} {10}{{0} {4}1{0} {10}}{0} {5}package{0} {11}Y{10};{0} {5}BEGIN{0} {10}{{0} {15}*bar{0} {10}={0} {10}\&{11}X{10}::{11}foo{10};{0} {10}}{0} {5}package{0} {11}Z{10};{0} {5}sub{0} {11}Y{10}::{11}bar{0} {10}:{0} {11}lvalue{0} {10};{0} {2}# built-in attributes for subroutines: {11}lvalue{0} {11}method{0} {5}prototype{10}(..){0} {11}locked{0} {11}const{0} {2}#-------------------------------------------------------------------------- # end of test file #-------------------------------------------------------------------------- tmpok_q575y/lexilla/test/examples/perl/perl-test-5220delta.pl0000664000175000017500000001350114773064066023616 0ustar gusnangusnan# -*- coding: utf-8 -*- #-------------------------------------------------------------------------- # perl-test-5220delta.pl #-------------------------------------------------------------------------- # REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod # maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod # also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22 # #-------------------------------------------------------------------------- # Kein-Hong Man Public Domain 20151217 #-------------------------------------------------------------------------- # 20151217 initial document # 20151218 updated tests and comments #-------------------------------------------------------------------------- use v5.22; # may be needed #-------------------------------------------------------------------------- # New bitwise operators #-------------------------------------------------------------------------- use feature 'bitwise' # enable feature, warning enabled use experimental "bitwise"; # enable feature, warning disabled # numerical operands 10&20 10|20 10^20 ~10 $a&"8" $a|"8" $a^"8" ~$a ~"8" # string operands '0'&."8" '0'|."8" '0'^."8" ~.'0' ~."8" # the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled # so it's feature-setting-dependent, no plans to change current behaviour $a&.10 $a|.10 $a^.10 ~.$a ~.10 # assignment variants $a&=10; $a|=10; $a^=10; $b&.='20'; $b|.='20'; $b^.='20'; $c&="30"; $c|="30"; $c^="30"; $d&.=$e; $d|.=$e; $d^.=$e; #-------------------------------------------------------------------------- # New double-diamond operator #-------------------------------------------------------------------------- # <<>> is like <> but each element of @ARGV will be treated as an actual file name # example snippet from brian d foy's blog post while( <<>> ) { # new, safe line input operator ...; } #-------------------------------------------------------------------------- # New \b boundaries in regular expressions #-------------------------------------------------------------------------- qr/\b{gcb}/ qr/\b{wb}/ qr/\b{sb}/ #-------------------------------------------------------------------------- # Non-Capturing Regular Expression Flag #-------------------------------------------------------------------------- # disables capturing and filling in $1, $2, etc "hello" =~ /(hi|hello)/n; # $1 is not set #-------------------------------------------------------------------------- # Aliasing via reference #-------------------------------------------------------------------------- # Variables and subroutines can now be aliased by assigning to a reference \$c = \$d; \&x = \&y; # Aliasing can also be applied to foreach iterator variables foreach \%hash (@array_of_hash_refs) { ... } # example snippet from brian d foy's blog post use feature qw(refaliasing); \%other_hash = \%hash; use v5.22; use feature qw(refaliasing); foreach \my %hash ( @array_of_hashes ) { # named hash control variable foreach my $key ( keys %hash ) { # named hash now! ...; } } #-------------------------------------------------------------------------- # New :const subroutine attribute #-------------------------------------------------------------------------- my $x = 54321; *INLINED = sub : const { $x }; $x++; # more examples of attributes # (not 5.22 stuff, but some general examples for study, useful for # handling subroutine signature and subroutine prototype highlighting) sub foo : lvalue ; package X; sub Y::x : lvalue { 1 } package X; sub foo { 1 } package Y; BEGIN { *bar = \&X::foo; } package Z; sub Y::bar : lvalue ; # built-in attributes for subroutines: lvalue method prototype(..) locked const #-------------------------------------------------------------------------- # Repetition in list assignment #-------------------------------------------------------------------------- # example snippet from brian d foy's blog post use v5.22; my(undef, $card_num, (undef)x3, $count) = split /:/; (undef,undef,$foo) = that_function() # is equivalent to ((undef)x2, $foo) = that_function() #-------------------------------------------------------------------------- # Floating point parsing has been improved #-------------------------------------------------------------------------- # Hexadecimal floating point literals # some hex floats from a program by Rick Regan # appropriated and extended from Lua 5.2.x test cases # tested on perl 5.22/cygwin 0x1p-1074; 0x3.3333333333334p-5; 0xcc.ccccccccccdp-11; 0x1p+1; 0x1p-6; 0x1.b7p-1; 0x1.fffffffffffffp+1023; 0x1p-1022; 0X1.921FB4D12D84AP+1; 0x1.999999999999ap-4; # additional test cases for characterization 0x1p-1074. # dot is a string operator 0x.ABCDEFp10 # legal, dot immediately after 0x 0x.p10 # perl allows 0x as a zero, then concat with p10 bareword 0x.p 0x0.p # dot then bareword 0x_0_.A_BC___DEF_p1_0 # legal hex float, underscores are mostly allowed 0x0._ABCDEFp10 # _ABCDEFp10 is a bareword, no underscore allowed after dot # illegal, but does not use error highlighting 0x0p1ABC # illegal, highlighted as 0x0p1 abut with bareword ABC # allowed to FAIL for now 0x0.ABCDEFp_10 # ABCDEFp_10 is a bareword, '_10' exponent not allowed 0xp 0xp1 0x0.0p # syntax errors 0x41.65.65 # hex dot number, but lexer now fails with 0x41.65 left as a partial hex float #-------------------------------------------------------------------------- # Support for ?PATTERN? without explicit operator has been removed #-------------------------------------------------------------------------- # ?PATTERN? must now be written as m?PATTERN? ?PATTERN? # does not work in current LexPerl anyway, NO ACTION NEEDED m?PATTERN? #-------------------------------------------------------------------------- # end of test file #-------------------------------------------------------------------------- tmpok_q575y/lexilla/test/examples/perl/perl-test-5220delta.pl.styled0000664000175000017500000001743614773064066025134 0ustar gusnangusnan{2}# -*- coding: utf-8 -*- #-------------------------------------------------------------------------- # perl-test-5220delta.pl #-------------------------------------------------------------------------- # REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod # maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod # also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22 # #-------------------------------------------------------------------------- # Kein-Hong Man Public Domain 20151217 #-------------------------------------------------------------------------- # 20151217 initial document # 20151218 updated tests and comments #-------------------------------------------------------------------------- {0} {5}use{0} {6}v5.22{10};{0} {2}# may be needed {0} {2}#-------------------------------------------------------------------------- # New bitwise operators #-------------------------------------------------------------------------- {0} {5}use{0} {11}feature{0} {7}'bitwise'{0} {2}# enable feature, warning enabled {5}use{0} {11}experimental{0} {6}"bitwise"{10};{0} {2}# enable feature, warning disabled {0} {2}# numerical operands {4}10{10}&{4}20{0} {4}10{10}|{4}20{0} {4}10{10}^{4}20{0} {10}~{4}10{0} {12}$a{10}&{6}"8"{0} {12}$a{10}|{6}"8"{0} {12}$a{10}^{6}"8"{0} {10}~{12}$a{0} {10}~{6}"8"{0} {2}# string operands {7}'0'{10}&.{6}"8"{0} {7}'0'{10}|.{6}"8"{0} {7}'0'{10}^.{6}"8"{0} {10}~.{7}'0'{0} {10}~.{6}"8"{0} {2}# the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled # so it's feature-setting-dependent, no plans to change current behaviour {0} {12}$a{10}&{4}.10{0} {12}$a{10}|{4}.10{0} {12}$a{10}^{4}.10{0} {10}~.{12}$a{0} {10}~{4}.10{0} {2}# assignment variants {12}$a{10}&={4}10{10};{0} {12}$a{10}|={4}10{10};{0} {12}$a{10}^={4}10{10};{0} {12}$b{10}&.={7}'20'{10};{0} {12}$b{10}|.={7}'20'{10};{0} {12}$b{10}^.={7}'20'{10};{0} {12}$c{10}&={6}"30"{10};{0} {12}$c{10}|={6}"30"{10};{0} {12}$c{10}^={6}"30"{10};{0} {12}$d{10}&.={12}$e{10};{0} {12}$d{10}|.={12}$e{10};{0} {12}$d{10}^.={12}$e{10};{0} {2}#-------------------------------------------------------------------------- # New double-diamond operator #-------------------------------------------------------------------------- # <<>> is like <> but each element of @ARGV will be treated as an actual file name {0} {2}# example snippet from brian d foy's blog post {5}while{10}({0} {10}<<>>{0} {10}){0} {10}{{0} {2}# new, safe line input operator {0} {10}...;{0} {10}}{0} {2}#-------------------------------------------------------------------------- # New \b boundaries in regular expressions #-------------------------------------------------------------------------- {0} {29}qr/\b{gcb}/{0} {29}qr/\b{wb}/{0} {29}qr/\b{sb}/{0} {2}#-------------------------------------------------------------------------- # Non-Capturing Regular Expression Flag #-------------------------------------------------------------------------- # disables capturing and filling in $1, $2, etc {0} {6}"hello"{0} {10}=~{0} {17}/(hi|hello)/n{10};{0} {2}# $1 is not set {0} {2}#-------------------------------------------------------------------------- # Aliasing via reference #-------------------------------------------------------------------------- # Variables and subroutines can now be aliased by assigning to a reference {0} {10}\{12}$c{0} {10}={0} {10}\{12}$d{10};{0} {10}\&{11}x{0} {10}={0} {10}\&{11}y{10};{0} {2}# Aliasing can also be applied to foreach iterator variables {0} {5}foreach{0} {10}\{14}%hash{0} {10}({13}@array_of_hash_refs{10}){0} {10}{{0} {10}...{0} {10}}{0} {2}# example snippet from brian d foy's blog post {0} {5}use{0} {11}feature{0} {30}qw(refaliasing){10};{0} {10}\{14}%other_hash{0} {10}={0} {10}\{14}%hash{10};{0} {5}use{0} {6}v5.22{10};{0} {5}use{0} {11}feature{0} {30}qw(refaliasing){10};{0} {5}foreach{0} {10}\{5}my{0} {14}%hash{0} {10}({0} {13}@array_of_hashes{0} {10}){0} {10}{{0} {2}# named hash control variable {0} {5}foreach{0} {5}my{0} {12}$key{0} {10}({0} {5}keys{0} {14}%hash{0} {10}){0} {10}{{0} {2}# named hash now! {0} {10}...;{0} {10}}{0} {10}}{0} {2}#-------------------------------------------------------------------------- # New :const subroutine attribute #-------------------------------------------------------------------------- {0} {5}my{0} {12}$x{0} {10}={0} {4}54321{10};{0} {15}*INLINED{0} {10}={0} {5}sub{0} {10}:{0} {11}const{0} {10}{{0} {12}$x{0} {10}};{0} {12}$x{10}++;{0} {2}# more examples of attributes # (not 5.22 stuff, but some general examples for study, useful for # handling subroutine signature and subroutine prototype highlighting) {0} {5}sub{0} {11}foo{0} {10}:{0} {11}lvalue{0} {10};{0} {5}package{0} {11}X{10};{0} {5}sub{0} {11}Y{10}::{11}x{0} {10}:{0} {11}lvalue{0} {10}{{0} {4}1{0} {10}}{0} {5}package{0} {11}X{10};{0} {5}sub{0} {11}foo{0} {10}{{0} {4}1{0} {10}}{0} {5}package{0} {11}Y{10};{0} {5}BEGIN{0} {10}{{0} {15}*bar{0} {10}={0} {10}\&{11}X{10}::{11}foo{10};{0} {10}}{0} {5}package{0} {11}Z{10};{0} {5}sub{0} {11}Y{10}::{11}bar{0} {10}:{0} {11}lvalue{0} {10};{0} {2}# built-in attributes for subroutines: {11}lvalue{0} {11}method{0} {5}prototype{10}(..){0} {11}locked{0} {11}const{0} {2}#-------------------------------------------------------------------------- # Repetition in list assignment #-------------------------------------------------------------------------- {0} {2}# example snippet from brian d foy's blog post {5}use{0} {6}v5.22{10};{0} {5}my{10}({5}undef{10},{0} {12}$card_num{10},{0} {10}({5}undef{10})x{4}3{10},{0} {12}$count{10}){0} {10}={0} {5}split{0} {17}/:/{10};{0} {10}({5}undef{10},{5}undef{10},{12}$foo{10}){0} {10}={0} {11}that_function{10}(){0} {2}# is equivalent to {10}(({5}undef{10})x{4}2{10},{0} {12}$foo{10}){0} {10}={0} {11}that_function{10}(){0} {2}#-------------------------------------------------------------------------- # Floating point parsing has been improved #-------------------------------------------------------------------------- # Hexadecimal floating point literals {0} {2}# some hex floats from a program by Rick Regan # appropriated and extended from Lua 5.2.x test cases # tested on perl 5.22/cygwin {0} {4}0x1p-1074{10};{0} {4}0x3.3333333333334p-5{10};{0} {4}0xcc.ccccccccccdp-11{10};{0} {4}0x1p+1{10};{0} {4}0x1p-6{10};{0} {4}0x1.b7p-1{10};{0} {4}0x1.fffffffffffffp+1023{10};{0} {4}0x1p-1022{10};{0} {4}0X1.921FB4D12D84AP+1{10};{0} {4}0x1.999999999999ap-4{10};{0} {2}# additional test cases for characterization {4}0x1p-1074{10}.{0} {2}# dot is a string operator {4}0x.ABCDEFp10{0} {2}# legal, dot immediately after 0x {4}0x{10}.{11}p10{0} {2}# perl allows 0x as a zero, then concat with p10 bareword {4}0x{10}.{11}p{0} {4}0x0{10}.{11}p{0} {2}# dot then bareword {4}0x_0_.A_BC___DEF_p1_0{0} {2}# legal hex float, underscores are mostly allowed {4}0x0{10}.{11}_ABCDEFp10{0} {2}# _ABCDEFp10 is a bareword, no underscore allowed after dot {0} {2}# illegal, but does not use error highlighting {4}0x0p1{11}ABC{0} {2}# illegal, highlighted as 0x0p1 abut with bareword ABC {0} {2}# allowed to FAIL for now {4}0x0.ABCDEFp_10{0} {2}# ABCDEFp_10 is a bareword, '_10' exponent not allowed {4}0xp{0} {4}0xp1{0} {4}0x0.0p{0} {2}# syntax errors {4}0x41.65{10}.{4}65{0} {2}# hex dot number, but lexer now fails with 0x41.65 left as a partial hex float {0} {2}#-------------------------------------------------------------------------- # Support for ?PATTERN? without explicit operator has been removed #-------------------------------------------------------------------------- # ?PATTERN? must now be written as m?PATTERN? {0} {10}?{11}PATTERN{10}?{0} {2}# does not work in current LexPerl anyway, NO ACTION NEEDED {17}m?PATTERN?{0} {2}#-------------------------------------------------------------------------- # end of test file #-------------------------------------------------------------------------- tmpok_q575y/lexilla/test/examples/fsharp/0000775000175000017500000000000014773064066020263 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/fsharp/Issue93.fs0000664000175000017500000000201514773064066022057 0ustar gusnangusnan(* (** nested comment 1 **) (* nested comment 2 (* nested comment 3 (* nested comment 4 (* nested comment 5 *) *) *) *) *) // declare a namespace // for the module namespace Issue93 module NestedComments = open FSharp.Quotations open FSharp.Quotations.Patterns // print the arguments // of an evaluated expression (* Example: (* printArgs <@ 1 + 2 @> ;; // 1 // 2 *) *) let printArgs expr = let getVal = function Value (v, _) -> downcast v | _ -> null match expr with | Call (_, _, args) -> List.map getVal args |> List.iter (printfn "%A") | _ -> printfn "not an evaluated expression" (* Example: (* let constExpr = <@ true @> ;; printArgs constExpr ;; *) *) // Prints: // "not an evaluated expression" tmpok_q575y/lexilla/test/examples/fsharp/x.fs.styled0000664000175000017500000000447114773064066022375 0ustar gusnangusnan{9}// x.fs // Sample source file to test F# syntax highlighting {0} {18}[]{0} {1}module{0} {6}Example{0} {11}#line 7 "A compiler directive"{0} {10}#if DEBUG{0} {1}open{0} {3}System{0} {1}open{0} {3}System{0}.{3}IO{0} {1}open{0} {3}System{0}.{6}Diagnostics{0} {10}#endif{0} {11}# 14 @"See: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/strings#remarks"{0} {9}// verbatim string {1}let{0} {6}xmlFragment1{0} {12}={0} {16}@""{0} {9}// triple-quoted string {1}let{0} {6}xmlFragment2{0} {12}={0} {15}""""""{0} {8}(* you need .NET 5.0 to compile this: https://docs.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-50#string-interpolation *){0} {1}let{0} {6}interpolated{0} {12}={0} {15}$"""C:\{System.DateTime.Now.ToString("yyyy-MM-dd")}\"""{0} {12}+{0} {15}$"{System.Random().Next(System.Int32.MaxValue)}.log"{0} {1}let{0} {7}``a byte literal``{0} {12}={0} {14}'\209'B{0} {9}// quoted expression {1}let{0} {6}expr{0} {12}={0} {17}<@@ let foo () = "bar" foo () @@>{0} {1}let{0} {6}bigNum{0} {12}({6}unused{12}:{0} {12}'{6}a{12}):{0} {3}float{0} {3}option{0} {12}={0} {3}Seq{0}.{2}init{0} {13}10_000{0} {12}({3}float{0} {12}>>{0} {12}({1}fun{0} {6}i{0} {12}->{0} {6}i{0} {12}+{0} {13}11.{12})){0} {12}|>{0} {12}({3}List{0}.{2}ofSeq{0} {12}>>{0} {3}List{0}.{2}take{0} {13}5{0} {12}>>{0} {3}List{0}.{2}fold{0} {12}(*){0} {13}1.0{12}){0} {12}|>{0} {3}Some{0} {1}match{0} {6}bigNum{0} {1}(){0} {1}with{0} {12}|{0} {3}Some{0} {6}num{0} {12}->{0} {2}sprintf{0} {15}"{19}%.2f{15} > {19}%u{15}"{0} {6}num{0} {7}``a byte literal``{0} {12}|{0} {3}None{0} {12}->{0} {2}sprintf{0} {15}"{19}%A{15}"{0} {15}"Have a byte string!"B{0} {12}|>{0} {2}printfn{0} {15}"{19}%s{15}"{0} {9}// GitHub Issue #38 {1}let{0} {6}unescapeWinPath{0} {12}({6}path{12}:{0} {3}string{12}){0} {12}={0} {6}path{0}.{6}Replace{12}({15}"\\\\"{12},{0} {15}"\\"{12}){0}.{6}Replace{12}({15}"\""{12},{0} {15}""{12}){0} {6}unescapeWinPath{0} {15}"\\\"Program Files (x86)\\Windows NT\\Accessories\\\""{0} {12}|>{0} {3}System{0}.{3}IO{0}.{6}Directory{0}.{6}GetFiles{0} {12}|>{0} {2}printfn{0} {15}"{19}%A{15}"{0} tmpok_q575y/lexilla/test/examples/fsharp/x.fs.folded0000664000175000017500000000424514773064066022325 0ustar gusnangusnan 2 400 401 + // x.fs 0 401 400 | // Sample source file to test F# syntax highlighting 1 400 400 0 400 400 [] 0 400 400 module Example 1 400 400 0 400 400 #line 7 "A compiler directive" 2 400 401 + #if DEBUG 2 401 402 + open System 0 402 402 | open System.IO 0 402 401 | open System.Diagnostics 0 401 400 | #endif 1 400 400 0 400 400 # 14 @"See: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/strings#remarks" 0 400 400 // verbatim string 0 400 400 let xmlFragment1 = @"" 1 400 400 0 400 400 // triple-quoted string 0 400 400 let xmlFragment2 = """""" 1 400 400 2 400 401 + (* you need .NET 5.0 to compile this: 0 401 401 | https://docs.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-50#string-interpolation 0 401 400 | *) 0 400 400 let interpolated = $"""C:\{System.DateTime.Now.ToString("yyyy-MM-dd")}\""" + $"{System.Random().Next(System.Int32.MaxValue)}.log" 1 400 400 0 400 400 let ``a byte literal`` = '\209'B 1 400 400 0 400 400 // quoted expression 0 400 400 let expr = 0 400 400 <@@ 0 400 400 let foo () = "bar" 0 400 400 foo () 0 400 400 @@> 1 400 400 0 400 400 let bigNum (unused: 'a): float option = 0 400 400 Seq.init 10_000 (float >> (fun i -> i + 11.)) 0 400 400 |> (List.ofSeq 0 400 400 >> List.take 5 0 400 400 >> List.fold (*) 1.0) 0 400 400 |> Some 1 400 400 0 400 400 match bigNum () with 0 400 400 | Some num -> sprintf "%.2f > %u" num ``a byte literal`` 0 400 400 | None -> sprintf "%A" "Have a byte string!"B 0 400 400 |> printfn "%s" 1 400 400 0 400 400 // GitHub Issue #38 0 400 400 let unescapeWinPath (path: string) = 0 400 400 path.Replace("\\\\", "\\").Replace("\"", "") 1 400 400 0 400 400 unescapeWinPath "\\\"Program Files (x86)\\Windows NT\\Accessories\\\"" 0 400 400 |> System.IO.Directory.GetFiles 0 400 400 |> printfn "%A" 0 400 0 tmpok_q575y/lexilla/test/examples/fsharp/Literals.fs.styled0000664000175000017500000000767114773064066023712 0ustar gusnangusnan{1}namespace{0} {6}Literals{0} {1}module{0} {6}Issue110{0} {12}={0} {1}let{0} {6}hexA{0} {12}={0} {13}+0xA1B2C3D4{0} {1}let{0} {6}hexB{0} {12}={0} {13}-0xCC100000{0} {9}// regression checks {0} {1}let{0} {6}hexC{0} {12}={0} {13}0xCC100000{0} {1}let{0} {6}binA{0} {12}={0} {13}+0b0000_1010{0} {1}let{0} {6}binB{0} {12}={0} {13}-0b1010_0000{0} {1}let{0} {6}binC{0} {12}={0} {13}0b1010_0000{0} {1}let{0} {6}octA{0} {12}={0} {13}+0o1237777700{0} {1}let{0} {6}octB{0} {12}={0} {13}-0o1237777700{0} {1}let{0} {6}octC{0} {12}={0} {13}0o1237777700{0} {1}let{0} {6}i8a{0} {12}={0} {13}+0001y{0} {1}let{0} {6}i8b{0} {12}={0} {13}-0001y{0} {1}let{0} {6}u8{0} {12}={0} {13}0001uy{0} {1}let{0} {6}f32a{0} {12}={0} {13}+0.001e-003{0} {1}let{0} {6}f32b{0} {12}={0} {13}-0.001E+003{0} {1}let{0} {6}f32c{0} {12}={0} {13}0.001e-003{0} {1}let{0} {6}f128a{0} {12}={0} {13}+0.001m{0} {1}let{0} {6}f128b{0} {12}={0} {13}-0.001m{0} {1}let{0} {6}f128c{0} {12}={0} {13}0.001m{0} {9}// invalid literals {0} {1}let{0} {6}hexD{0} {12}={0} {13}0xa0bcde0{0}o {1}let{0} {6}hexE{0} {12}={0} {13}+0xa0bcd0{0}o {1}let{0} {6}hexF{0} {12}={0} {13}-0xa0bcd0{0}o {1}let{0} {6}binD{0} {12}={0} {13}0b1010_1110{0}x{6}f000{0} {1}let{0} {6}binE{0} {12}={0} {13}+0b1010_1110{0}x{6}f000{0} {1}let{0} {6}binF{0} {12}={0} {13}-0b1010_1110{0}x{6}f000{0} {1}let{0} {6}binG{0} {12}={0} {13}0b1010_1110{0}o {1}let{0} {6}binH{0} {12}={0} {13}+0b1010_1110{0}o {1}let{0} {6}binI{0} {12}={0} {13}-0b1010_1110{0}o {1}let{0} {6}octD{0} {12}={0} {13}0o3330{0}x{6}aBcDeF{0} {1}let{0} {6}octE{0} {12}={0} {13}+0o3330{0}x{6}aBcDe{0} {1}let{0} {6}octF{0} {12}={0} {13}-0o3330{0}x{6}aBcDe{0} {1}let{0} {6}octG{0} {12}={0} {13}0o3330{0}b {1}let{0} {6}octH{0} {12}={0} {13}0o3330{0}b {1}let{0} {6}octI{0} {12}={0} {13}0o3330{0}b {1}module{0} {6}Issue111{0} {12}={0} {9}// invalid literals {0} {1}let{0} {6}a{0} {12}={0} {13}0000_123{0}a{6}bc{0} {1}let{0} {6}b{0} {12}={0} {13}+000_123{0}a{6}bc{0} {1}let{0} {6}c{0} {12}={0} {13}-0001_23{0}a{6}bc{0} {1}let{0} {6}d{0} {12}={0} {13}00123_000{0}b {1}let{0} {6}e{0} {12}={0} {13}+0123_000{0}o {1}let{0} {6}f{0} {12}={0} {13}-0123_000{0}x{6}cd{0} {1}module{0} {6}Issue112{0} {12}={0} {1}let{0} {6}i64{0} {12}={0} {13}0001L{0} {1}let{0} {6}u64{0} {12}={0} {13}001UL{0} {1}let{0} {6}f32a{0} {12}={0} {13}001.F{0} {1}let{0} {6}f32b{0} {12}={0} {13}+01.0F{0} {1}let{0} {6}f32c{0} {12}={0} {13}-01.00000F{0} {1}let{0} {6}f32d{0} {12}={0} {13}0b0000_0010lf{0} {1}let{0} {6}f32e{0} {12}={0} {13}0o000_010lf{0} {1}let{0} {6}f32f{0} {12}={0} {13}0x0000000000000010lf{0} {1}let{0} {6}f64a{0} {12}={0} {13}0b0000_0010LF{0} {1}let{0} {6}f64b{0} {12}={0} {13}0o000_010LF{0} {1}let{0} {6}f64c{0} {12}={0} {13}0x0000000000000010LF{0} {1}let{0} {6}f128a{0} {12}={0} {13}001.M{0} {1}let{0} {6}f128b{0} {12}={0} {13}+01.0M{0} {1}let{0} {6}f128c{0} {12}={0} {13}-01.00000M{0} {9}// regression checks {0} {1}let{0} {6}i32{0} {12}={0} {13}-0001l{0} {1}let{0} {6}u32{0} {12}={0} {13}+001ul{0} {1}let{0} {6}i128{0} {12}={0} {13}9999999999999999999999999999I{0} {1}let{0} {6}f32g{0} {12}={0} {13}001.f{0} {1}let{0} {6}f32h{0} {12}={0} {13}+01.0f{0} {1}let{0} {6}f32i{0} {12}={0} {13}-01.00000f{0} {1}let{0} {6}f64d{0} {12}={0} {13}010000e+009{0} {1}let{0} {6}f64e{0} {12}={0} {13}+001.0e-009{0} {1}let{0} {6}f64f{0} {12}={0} {13}-001.e+009{0} {1}let{0} {6}f128d{0} {12}={0} {13}001.m{0} {1}let{0} {6}f128e{0} {12}={0} {13}+01.0m{0} {1}let{0} {6}f128f{0} {12}={0} {13}-01.00000m{0} {9}// arithmetic expressions {0} {1}let{0} {6}a{0} {12}={0} {13}-001.f{12}+{13}01.0F{0} {1}let{0} {6}b{0} {12}={0} {13}+0b0111_111UL{12}-{13}0x100UL{0} {1}let{0} {6}c{0} {12}={0} {13}-01.0F{0} {12}+{0} {13}+001.f{0} {1}let{0} {6}d{0} {12}={0} {13}-0x100UL{0} {12}-{0} {13}+0b0111_111UL{0} tmpok_q575y/lexilla/test/examples/fsharp/FmtSpecs.fs.folded0000664000175000017500000000400414773064066023573 0ustar gusnangusnan 0 400 400 module FormatSpecifiersTest 1 400 400 0 400 400 let x = List.fold (*) 24.5 [ 1.; 2.; 3. ] 1 400 400 0 400 400 // expect "147.00" 0 400 400 printfn "Speed: %.2f m/s" x 0 400 400 printfn $"Speed: %.2f{x} m/s" 0 400 400 printfn $"Speed: {x:f2} m/s" 0 400 400 printfn $@"Speed: %.2f{x} m/s" 0 400 400 printfn @$"Speed: {x:f2} m/s" 1 400 400 0 400 400 // expect " 147%" 0 400 400 printfn """%% increase:% .0F%% over last year""" x 0 400 400 printfn $"""%% increase:% .0F{x}%% over last year""" 0 400 400 printfn $"""%% increase:{x / 100.,5:P0} over last year""" 0 400 400 printfn $@"""%% increase:% .0F{x}%% over last year""" 0 400 400 printfn @$"""%% increase:{x / 100.,5:P0} over last year""" 1 400 400 2 400 401 + // expect "1.5E+002" 0 401 400 | // NB: units should look like text even without a space 0 400 400 printfn @"Time: %-0.1Esecs" x 0 400 400 printfn $"Time: %-0.1E{x}secs" 0 400 400 printfn $"Time: {x:E1}secs" 0 400 400 printfn $@"Time: %-0.1E{x}secs" 0 400 400 printfn @$"Time: {x:E1}secs" 1 400 400 0 400 400 // expect "\" +147\"" 0 400 400 printfn @"""Temp: %+12.3g K""" x 0 400 400 printfn $"""{'"'}Temp: %+12.3g{x} K{'"'}""" 0 400 400 printfn $"""{'"'}Temp: {'+',9}{x:g3} K{'"'}""" 0 400 400 printfn $@"""Temp: %+12.3g{x} K""" 0 400 400 printfn @$"""Temp: {'+',9}{x:g3} K""" 1 400 400 0 400 400 // Since F# 6.0 0 400 400 printfn @"%B" 0b1_000_000 0 400 400 printfn "%B" "\x40"B.[0] 0 400 400 printfn $"""%B{'\064'B}""" 0 400 400 printfn $@"""%B{0b1_000_000}""" 0 400 400 printfn @$"""%B{'\064'B}""" 1 400 400 0 400 400 // These don't work 0 400 400 printfn ``%.2f`` x 0 400 400 printfn $"%.2f" x 0 400 400 printfn $@"%.2f" x 0 400 400 printfn @$"%.2f" x 0 400 400 printfn $"%.2f {x}" 0 400 400 printfn $@"%.2f {x}" 0 400 400 printfn @$"%.2f {x}" 0 400 400 printfn $"""%.2f {x}""" 0 400 400 printfn $@"""%.2f {x}""" 0 400 400 printfn @$"""%.2f {x}""" 0 400 0 tmpok_q575y/lexilla/test/examples/fsharp/SciTE.properties0000664000175000017500000000545314773064066023357 0ustar gusnangusnanlexer.*.fs=fsharp keywords.*.fs= \ abstract and as assert base begin class default delegate do done downcast \ downto elif else end exception extern false finally fixed for fun function \ global if in inherit inline interface internal lazy let let! match match! \ member module mutable namespace new null of open or override private public \ rec return return! select static struct then to true try type upcast use use! \ val void when while with yield yield! atomic break checked component const \ constraint constructor continue eager event external fixed functor global \ include method mixin object parallel process protected pure sealed tailcall \ trait virtual volatile keywords2.*.fs= \ asr land lor lsl lsr lxor mod sig abs acos add allPairs append asin atan atan2 \ average averageBy base1 base2 blit cache cast ceil choose \ chunkBySize collect compareWith concat contains containsKey copy cos cosh count \ countBy create createBased delay difference distinct distinctBy empty eprintf except \ exists exists2 exactlyOne failwith fill filter find findBack findIndex findIndexBack \ findKey floor fold fold2 foldBack foldBack2 forall forall2 fprintf fst get groupBy head ignore indexed \ init initBased initInfinite intersect intersectMany invalidArg isEmpty isProperSubset \ isProperSuperset isSubset isSuperset item iter iter2 iteri iteri2 last length \ length1 length2 length3 length4 map map2 map3 mapFold mapFoldBack mapi mapi2 \ max maxBy maxElement min minBy minElement nameof not ofArray ofList ofSeq pairwise partition \ permute pick pown printf printfn raise readonly rebase reduce reduceBack remove replicate rev round scan \ scanBack seq set sin sinh singleton skip skipWhile snd sort sortBy sortByDescending sortDescending \ sortInPlace sortInPlaceBy sortInPlaceWith sortWith splitAt splitInto sprintf sqrt sub sum \ sumBy tail take takeWhile tan tanh toArray toList toSeq transpose truncate \ tryExactlyOne tryFind tryFindBack tryFindIndex tryFindIndexBack tryHead \ tryItem tryFindKey tryLast tryPick typeof unfold union unionMany unzip unzip3 where \ windowed zeroCreate zeroCreateBased zip zip3 keywords3.*.fs= \ ArgumentException Array Array2D Array3D Array4D BigInteger Boolean Byte Char Collections Core CultureInfo DateTime Decimal Double \ Environment Expr Float FSharp Globalization Int16 Int32 Int64 IntPtr IO Linq List Map Math Microsoft NumberStyles \ Object Parallel Printf Random ResizeArray SByte Seq Set Single String System UInt16 UInt32 UInt64 UIntPtr \ array bigint bool byte byref char comparison decimal double enum equality Error Exception exn float float32 inref int int8 int16 \ int32 int64 list nativeint nativeptr None obj Ok option Option outref ref Result sbyte Some single string unmanaged unativeint \ uint uint8 uint16 uint32 uint64 unit void voidptr voption fold.fsharp.preprocessor=1 fold.comment=1 tmpok_q575y/lexilla/test/examples/fsharp/Literals.fs0000664000175000017500000000375414773064066022405 0ustar gusnangusnannamespace Literals module Issue110 = let hexA = +0xA1B2C3D4 let hexB = -0xCC100000 // regression checks let hexC = 0xCC100000 let binA = +0b0000_1010 let binB = -0b1010_0000 let binC = 0b1010_0000 let octA = +0o1237777700 let octB = -0o1237777700 let octC = 0o1237777700 let i8a = +0001y let i8b = -0001y let u8 = 0001uy let f32a = +0.001e-003 let f32b = -0.001E+003 let f32c = 0.001e-003 let f128a = +0.001m let f128b = -0.001m let f128c = 0.001m // invalid literals let hexD = 0xa0bcde0o let hexE = +0xa0bcd0o let hexF = -0xa0bcd0o let binD = 0b1010_1110xf000 let binE = +0b1010_1110xf000 let binF = -0b1010_1110xf000 let binG = 0b1010_1110o let binH = +0b1010_1110o let binI = -0b1010_1110o let octD = 0o3330xaBcDeF let octE = +0o3330xaBcDe let octF = -0o3330xaBcDe let octG = 0o3330b let octH = 0o3330b let octI = 0o3330b module Issue111 = // invalid literals let a = 0000_123abc let b = +000_123abc let c = -0001_23abc let d = 00123_000b let e = +0123_000o let f = -0123_000xcd module Issue112 = let i64 = 0001L let u64 = 001UL let f32a = 001.F let f32b = +01.0F let f32c = -01.00000F let f32d = 0b0000_0010lf let f32e = 0o000_010lf let f32f = 0x0000000000000010lf let f64a = 0b0000_0010LF let f64b = 0o000_010LF let f64c = 0x0000000000000010LF let f128a = 001.M let f128b = +01.0M let f128c = -01.00000M // regression checks let i32 = -0001l let u32 = +001ul let i128 = 9999999999999999999999999999I let f32g = 001.f let f32h = +01.0f let f32i = -01.00000f let f64d = 010000e+009 let f64e = +001.0e-009 let f64f = -001.e+009 let f128d = 001.m let f128e = +01.0m let f128f = -01.00000m // arithmetic expressions let a = -001.f+01.0F let b = +0b0111_111UL-0x100UL let c = -01.0F + +001.f let d = -0x100UL - +0b0111_111UL tmpok_q575y/lexilla/test/examples/fsharp/Issue56.fs.styled0000664000175000017500000000047614773064066023372 0ustar gusnangusnan{9}// not folded {0} {9}// first line in comment fold // second . . . // third . . . {1}namespace{0} {6}Issue56{0} {1}open{0} {3}System{0} {1}module{0} {6}LineBasedFoldingCheck{0} {12}={0} {1}open{0} {3}FSharp{0}.{6}Quotations{0} {1}open{0} {3}FSharp{0}.{6}Reflection{0} {1}(){0} {12}|>{0} {2}ignore{0} tmpok_q575y/lexilla/test/examples/fsharp/FmtSpecs.fs.styled0000664000175000017500000000437114773064066023651 0ustar gusnangusnan{1}module{0} {6}FormatSpecifiersTest{0} {1}let{0} {6}x{0} {12}={0} {3}List{0}.{2}fold{0} {12}(*){0} {13}24.5{0} {12}[{0} {13}1.{12};{0} {13}2.{12};{0} {13}3.{0} {12}]{0} {9}// expect "147.00" {2}printfn{0} {15}"Speed: {19}%.2f{15} m/s"{0} {6}x{0} {2}printfn{0} {15}$"Speed: {19}%.2f{15}{x} m/s"{0} {2}printfn{0} {15}$"Speed: {x{19}:f2{15}} m/s"{0} {2}printfn{0} {16}$@"Speed: {19}%.2f{16}{x} m/s"{0} {2}printfn{0} {16}@$"Speed: {x{19}:f2{16}} m/s"{0} {9}// expect " 147%" {2}printfn{0} {15}"""{19}%%{15} increase:{19}% .0F%%{15} over last year"""{0} {6}x{0} {2}printfn{0} {15}$"""{19}%%{15} increase:{19}% .0F{15}{x}{19}%%{15} over last year"""{0} {2}printfn{0} {15}$"""{19}%%{15} increase:{x / 100.{19},5:P0{15}} over last year"""{0} {2}printfn{0} {16}$@"""{19}%%{16} increase:{19}% .0F{16}{x}{19}%%{16} over last year"""{0} {2}printfn{0} {16}@$"""{19}%%{16} increase:{x / 100.{19},5:P0{16}} over last year"""{0} {9}// expect "1.5E+002" // NB: units should look like text even without a space {2}printfn{0} {16}@"Time: {19}%-0.1E{16}secs"{0} {6}x{0} {2}printfn{0} {15}$"Time: {19}%-0.1E{15}{x}secs"{0} {2}printfn{0} {15}$"Time: {x{19}:E1{15}}secs"{0} {2}printfn{0} {16}$@"Time: {19}%-0.1E{16}{x}secs"{0} {2}printfn{0} {16}@$"Time: {x{19}:E1{16}}secs"{0} {9}// expect "\" +147\"" {2}printfn{0} {16}@"""Temp: {19}%+12.3g{16} K"""{0} {6}x{0} {2}printfn{0} {15}$"""{'"'}Temp: {19}%+12.3g{15}{x} K{'"'}"""{0} {2}printfn{0} {15}$"""{'"'}Temp: {'+'{19},9{15}}{x{19}:g3{15}} K{'"'}"""{0} {2}printfn{0} {16}$@"""Temp: {19}%+12.3g{16}{x} K"""{0} {2}printfn{0} {16}@$"""Temp: {'+'{19},9{16}}{x{19}:g3{16}} K"""{0} {9}// Since F# 6.0 {2}printfn{0} {16}@"{19}%B{16}"{0} {13}0b1_000_000{0} {2}printfn{0} {15}"{19}%B{15}"{0} {15}"\x40"B{0}.{12}[{13}0{12}]{0} {2}printfn{0} {15}$"""{19}%B{15}{'\064'B}"""{0} {2}printfn{0} {16}$@"""{19}%B{16}{0b1_000_000}"""{0} {2}printfn{0} {16}@$"""{19}%B{16}{'\064'B}"""{0} {9}// These don't work {2}printfn{0} {7}``%.2f``{0} {6}x{0} {2}printfn{0} {15}$"%.2f"{0} {6}x{0} {2}printfn{0} {16}$@"%.2f"{0} {6}x{0} {2}printfn{0} {16}@$"%.2f"{0} {6}x{0} {2}printfn{0} {15}$"%.2f {x}"{0} {2}printfn{0} {16}$@"%.2f {x}"{0} {2}printfn{0} {16}@$"%.2f {x}"{0} {2}printfn{0} {15}$"""%.2f {x}"""{0} {2}printfn{0} {16}$@"""%.2f {x}"""{0} {2}printfn{0} {16}@$"""%.2f {x}"""{0} tmpok_q575y/lexilla/test/examples/fsharp/Issue56.fs0000664000175000017500000000032314773064066022056 0ustar gusnangusnan// not folded // first line in comment fold // second . . . // third . . . namespace Issue56 open System module LineBasedFoldingCheck = open FSharp.Quotations open FSharp.Reflection () |> ignore tmpok_q575y/lexilla/test/examples/fsharp/Issue93.fs.folded0000664000175000017500000000316014773064066023315 0ustar gusnangusnan 2 400 401 + (* 0 401 401 | (** nested comment 1 **) 2 401 402 + (* 0 402 402 | nested comment 2 2 402 403 + (* 0 403 403 | nested comment 3 2 403 404 + (* 0 404 404 | nested comment 4 2 404 405 + (* 0 405 405 | nested comment 5 0 405 404 | *) 0 404 403 | *) 0 403 402 | *) 0 402 401 | *) 0 401 400 | *) 2 400 401 + // declare a namespace 0 401 400 | // for the module 0 400 400 namespace Issue93 1 400 400 0 400 400 module NestedComments = 2 400 401 + open FSharp.Quotations 0 401 400 | open FSharp.Quotations.Patterns 2 400 401 + // print the arguments 0 401 400 | // of an evaluated expression 2 400 401 + (* Example: 2 401 402 + (* 0 402 402 | printArgs <@ 1 + 2 @> ;; 0 402 402 | // 1 0 402 402 | // 2 0 402 401 | *) 0 401 400 | *) 0 400 400 let printArgs expr = 0 400 400 let getVal = function Value (v, _) -> downcast v | _ -> null 0 400 400 match expr with 0 400 400 | Call (_, _, args) -> 0 400 400 List.map getVal args |> List.iter (printfn "%A") 0 400 400 | _ -> 0 400 400 printfn "not an evaluated expression" 2 400 401 + (* Example: 2 401 402 + (* 0 402 402 | let constExpr = <@ true @> ;; 0 402 402 | printArgs constExpr ;; 0 402 401 | *) 0 401 400 | *) 2 400 401 + // Prints: 0 401 400 | // "not an evaluated expression" 0 400 0 tmpok_q575y/lexilla/test/examples/fsharp/FmtSpecs.fs0000664000175000017500000000254014773064066022342 0ustar gusnangusnanmodule FormatSpecifiersTest let x = List.fold (*) 24.5 [ 1.; 2.; 3. ] // expect "147.00" printfn "Speed: %.2f m/s" x printfn $"Speed: %.2f{x} m/s" printfn $"Speed: {x:f2} m/s" printfn $@"Speed: %.2f{x} m/s" printfn @$"Speed: {x:f2} m/s" // expect " 147%" printfn """%% increase:% .0F%% over last year""" x printfn $"""%% increase:% .0F{x}%% over last year""" printfn $"""%% increase:{x / 100.,5:P0} over last year""" printfn $@"""%% increase:% .0F{x}%% over last year""" printfn @$"""%% increase:{x / 100.,5:P0} over last year""" // expect "1.5E+002" // NB: units should look like text even without a space printfn @"Time: %-0.1Esecs" x printfn $"Time: %-0.1E{x}secs" printfn $"Time: {x:E1}secs" printfn $@"Time: %-0.1E{x}secs" printfn @$"Time: {x:E1}secs" // expect "\" +147\"" printfn @"""Temp: %+12.3g K""" x printfn $"""{'"'}Temp: %+12.3g{x} K{'"'}""" printfn $"""{'"'}Temp: {'+',9}{x:g3} K{'"'}""" printfn $@"""Temp: %+12.3g{x} K""" printfn @$"""Temp: {'+',9}{x:g3} K""" // Since F# 6.0 printfn @"%B" 0b1_000_000 printfn "%B" "\x40"B.[0] printfn $"""%B{'\064'B}""" printfn $@"""%B{0b1_000_000}""" printfn @$"""%B{'\064'B}""" // These don't work printfn ``%.2f`` x printfn $"%.2f" x printfn $@"%.2f" x printfn @$"%.2f" x printfn $"%.2f {x}" printfn $@"%.2f {x}" printfn @$"%.2f {x}" printfn $"""%.2f {x}""" printfn $@"""%.2f {x}""" printfn @$"""%.2f {x}""" tmpok_q575y/lexilla/test/examples/fsharp/x.fs0000664000175000017500000000274714773064066021076 0ustar gusnangusnan// x.fs // Sample source file to test F# syntax highlighting [] module Example #line 7 "A compiler directive" #if DEBUG open System open System.IO open System.Diagnostics #endif # 14 @"See: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/strings#remarks" // verbatim string let xmlFragment1 = @"" // triple-quoted string let xmlFragment2 = """""" (* you need .NET 5.0 to compile this: https://docs.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-50#string-interpolation *) let interpolated = $"""C:\{System.DateTime.Now.ToString("yyyy-MM-dd")}\""" + $"{System.Random().Next(System.Int32.MaxValue)}.log" let ``a byte literal`` = '\209'B // quoted expression let expr = <@@ let foo () = "bar" foo () @@> let bigNum (unused: 'a): float option = Seq.init 10_000 (float >> (fun i -> i + 11.)) |> (List.ofSeq >> List.take 5 >> List.fold (*) 1.0) |> Some match bigNum () with | Some num -> sprintf "%.2f > %u" num ``a byte literal`` | None -> sprintf "%A" "Have a byte string!"B |> printfn "%s" // GitHub Issue #38 let unescapeWinPath (path: string) = path.Replace("\\\\", "\\").Replace("\"", "") unescapeWinPath "\\\"Program Files (x86)\\Windows NT\\Accessories\\\"" |> System.IO.Directory.GetFiles |> printfn "%A" tmpok_q575y/lexilla/test/examples/fsharp/Issue93.fs.styled0000664000175000017500000000265614773064066023375 0ustar gusnangusnan{8}(* (** nested comment 1 **) (* nested comment 2 (* nested comment 3 (* nested comment 4 (* nested comment 5 *) *) *) *) *){0} {9}// declare a namespace // for the module {1}namespace{0} {6}Issue93{0} {1}module{0} {6}NestedComments{0} {12}={0} {1}open{0} {3}FSharp{0}.{6}Quotations{0} {1}open{0} {3}FSharp{0}.{6}Quotations{0}.{6}Patterns{0} {9}// print the arguments {0} {9}// of an evaluated expression {0} {8}(* Example: (* printArgs <@ 1 + 2 @> ;; // 1 // 2 *) *){0} {1}let{0} {6}printArgs{0} {6}expr{0} {12}={0} {1}let{0} {6}getVal{0} {12}={0} {1}function{0} {6}Value{0} {12}({6}v{12},{0} {6}_{12}){0} {12}->{0} {1}downcast{0} {6}v{0} {12}|{0} {6}_{0} {12}->{0} {1}null{0} {1}match{0} {6}expr{0} {1}with{0} {12}|{0} {6}Call{0} {12}({6}_{12},{0} {6}_{12},{0} {6}args{12}){0} {12}->{0} {3}List{0}.{2}map{0} {6}getVal{0} {6}args{0} {12}|>{0} {3}List{0}.{2}iter{0} {12}({2}printfn{0} {15}"{19}%A{15}"{12}){0} {12}|{0} {6}_{0} {12}->{0} {2}printfn{0} {15}"not an evaluated expression"{0} {8}(* Example: (* let constExpr = <@ true @> ;; printArgs constExpr ;; *) *){0} {9}// Prints: {0} {9}// "not an evaluated expression" tmpok_q575y/lexilla/test/examples/fsharp/Issue56.fs.folded0000664000175000017500000000062614773064066023320 0ustar gusnangusnan 0 400 400 // not folded 1 400 400 2 400 401 + // first line in comment fold 0 401 401 | // second . . . 0 401 400 | // third . . . 0 400 400 namespace Issue56 1 400 400 0 400 400 open System 1 400 400 0 400 400 module LineBasedFoldingCheck = 2 400 401 + open FSharp.Quotations 0 401 400 | open FSharp.Reflection 1 400 400 0 400 400 () |> ignore 0 400 0 tmpok_q575y/lexilla/test/examples/fsharp/Literals.fs.folded0000664000175000017500000000611214773064066023630 0ustar gusnangusnan 0 400 400 namespace Literals 1 400 400 0 400 400 module Issue110 = 0 400 400 let hexA = +0xA1B2C3D4 0 400 400 let hexB = -0xCC100000 1 400 400 0 400 400 // regression checks 0 400 400 let hexC = 0xCC100000 0 400 400 let binA = +0b0000_1010 0 400 400 let binB = -0b1010_0000 0 400 400 let binC = 0b1010_0000 0 400 400 let octA = +0o1237777700 0 400 400 let octB = -0o1237777700 0 400 400 let octC = 0o1237777700 0 400 400 let i8a = +0001y 0 400 400 let i8b = -0001y 0 400 400 let u8 = 0001uy 0 400 400 let f32a = +0.001e-003 0 400 400 let f32b = -0.001E+003 0 400 400 let f32c = 0.001e-003 0 400 400 let f128a = +0.001m 0 400 400 let f128b = -0.001m 0 400 400 let f128c = 0.001m 1 400 400 0 400 400 // invalid literals 0 400 400 let hexD = 0xa0bcde0o 0 400 400 let hexE = +0xa0bcd0o 0 400 400 let hexF = -0xa0bcd0o 0 400 400 let binD = 0b1010_1110xf000 0 400 400 let binE = +0b1010_1110xf000 0 400 400 let binF = -0b1010_1110xf000 0 400 400 let binG = 0b1010_1110o 0 400 400 let binH = +0b1010_1110o 0 400 400 let binI = -0b1010_1110o 0 400 400 let octD = 0o3330xaBcDeF 0 400 400 let octE = +0o3330xaBcDe 0 400 400 let octF = -0o3330xaBcDe 0 400 400 let octG = 0o3330b 0 400 400 let octH = 0o3330b 0 400 400 let octI = 0o3330b 1 400 400 0 400 400 module Issue111 = 0 400 400 // invalid literals 0 400 400 let a = 0000_123abc 0 400 400 let b = +000_123abc 0 400 400 let c = -0001_23abc 0 400 400 let d = 00123_000b 0 400 400 let e = +0123_000o 0 400 400 let f = -0123_000xcd 1 400 400 0 400 400 module Issue112 = 0 400 400 let i64 = 0001L 0 400 400 let u64 = 001UL 0 400 400 let f32a = 001.F 0 400 400 let f32b = +01.0F 0 400 400 let f32c = -01.00000F 0 400 400 let f32d = 0b0000_0010lf 0 400 400 let f32e = 0o000_010lf 0 400 400 let f32f = 0x0000000000000010lf 0 400 400 let f64a = 0b0000_0010LF 0 400 400 let f64b = 0o000_010LF 0 400 400 let f64c = 0x0000000000000010LF 0 400 400 let f128a = 001.M 0 400 400 let f128b = +01.0M 0 400 400 let f128c = -01.00000M 1 400 400 0 400 400 // regression checks 0 400 400 let i32 = -0001l 0 400 400 let u32 = +001ul 0 400 400 let i128 = 9999999999999999999999999999I 0 400 400 let f32g = 001.f 0 400 400 let f32h = +01.0f 0 400 400 let f32i = -01.00000f 0 400 400 let f64d = 010000e+009 0 400 400 let f64e = +001.0e-009 0 400 400 let f64f = -001.e+009 0 400 400 let f128d = 001.m 0 400 400 let f128e = +01.0m 0 400 400 let f128f = -01.00000m 1 400 400 0 400 400 // arithmetic expressions 0 400 400 let a = -001.f+01.0F 0 400 400 let b = +0b0111_111UL-0x100UL 0 400 400 let c = -01.0F + +001.f 0 400 400 let d = -0x100UL - +0b0111_111UL 0 400 0 tmpok_q575y/lexilla/test/examples/css/0000775000175000017500000000000014773064066017570 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/css/AllStyles.css.folded0000664000175000017500000000426614773064066023462 0ustar gusnangusnan 0 400 0 /* Enumerate all styles: 0 to 23 */ 0 400 0 0 400 0 /* comment=9 */ 0 400 0 0 400 0 /* whitespace=0 */ 0 400 0 /* */ 0 400 0 0 400 0 /* tag=1 */ 0 400 0 html/**/ 0 400 0 {} 0 400 0 0 400 0 /* class=2 */ 0 400 0 .hidden 0 400 0 {} 0 400 0 0 400 0 /* pseudoclass=3 */ 0 400 0 :link 0 400 0 {} 0 400 0 0 400 0 /* unknown pseudoclass=4 */ 0 400 0 :unknown 0 400 0 {} 0 400 0 0 400 0 /* operator=5 */ 0 400 0 # 0 400 0 {} 0 400 0 0 400 0 /* identifier=6 */ 0 400 0 *{margin:} 0 400 0 0 400 0 /* unknown identifier=7 */ 0 400 0 *{unknown:} 0 400 0 0 400 0 /* value=8 */ 0 400 0 *{:88} 0 400 0 0 400 0 /* identifier=10 */ 0 400 0 #identifier 0 400 0 {} 0 400 0 0 400 0 /* important=11 */ 0 400 0 * { margin: 0 ! important; } 0 400 0 0 400 0 /* directive=12 */ 0 400 0 @directive 0 400 0 { } 0 400 0 0 400 0 /* doublestring=13 */ 0 400 0 * { font-family: "doublestring"; } 0 400 0 0 400 0 /* singlestring=14 */ 0 400 0 * { font-family: 'singlestring'; } 0 400 0 0 400 0 /* identifier2=15 */ 0 400 0 * { identifier2: 0} 0 400 0 0 400 0 /* attribute=16 */ 0 400 0 [attribute] 0 400 0 {} 0 400 0 0 400 0 /* identifier3=17 */ 0 400 0 * { identifier3: 0} 0 400 0 0 400 0 /* pseudoelement=18 */ 0 400 0 ::pseudoelement 0 400 0 {} 0 400 0 0 400 0 /* extended_identifier=19 */ 0 400 0 * { extended_identifier: 0} 0 400 0 0 400 0 /* extended_pseudoclass=20 */ 0 400 0 :extended_pseudoclass 0 400 0 {} 0 400 0 0 400 0 /* extended_pseudoelement=21 */ 0 400 0 ::extended_pseudo_element 0 400 0 {} 0 400 0 0 400 0 /* media=22 */ 0 400 0 @media (orientation: portrait) 0 400 0 { } 0 400 0 0 400 0 /* group rule=22 */ 0 400 0 @supports ( display: flex ) { 0 400 0 body { display: flex; } 0 400 0 } 0 400 0 0 400 0 /* variable=23 */ 0 400 0 $variable:#428bca; 0 400 0 tmpok_q575y/lexilla/test/examples/css/SciTE.properties0000664000175000017500000000075214773064066022661 0ustar gusnangusnanlexer.*.css=css # identifier keywords.*.css=margin # pseudoclass keywords2.*.css=link # identifier 2 keywords3.*.css=identifier2 # identifier 3 keywords4.*.css=identifier3 # pseudo elements keywords5.*.css=pseudoelement # extended identifier keywords6.*.css=extended_identifier # extended pseudoclass keywords7.*.css=extended_pseudoclass # extended pseudo elements keywords8.*.css=extended_pseudo_element # enable SCSS language so $variable is recognized lexer.css.scss.language=1 tmpok_q575y/lexilla/test/examples/css/AllStyles.css.styled0000664000175000017500000000322414773064066023522 0ustar gusnangusnan{9}/* Enumerate all styles: 0 to 23 */{0} {9}/* comment=9 */{0} {9}/* whitespace=0 */{0} {9}/* */{0} {9}/* tag=1 */{0} {1}html{9}/**/{1} {5}{}{0} {9}/* class=2 */{0} {5}.{2}hidden{1} {5}{}{0} {9}/* pseudoclass=3 */{0} {5}:{3}link{1} {5}{}{0} {9}/* unknown pseudoclass=4 */{0} {5}:{4}unknown{1} {5}{}{0} {9}/* operator=5 */{0} {5}#{1} {5}{}{0} {9}/* identifier=6 */{0} {1}*{5}{{6}margin{5}:}{0} {9}/* unknown identifier=7 */{0} {1}*{5}{{7}unknown{5}:}{0} {9}/* value=8 */{0} {1}*{5}{:{8}88{5}}{0} {9}/* identifier=10 */{0} {5}#{10}identifier{1} {5}{}{0} {9}/* important=11 */{0} {1}* {5}{{6} margin{5}:{8} 0 {5}!{11} important{5};{6} {5}}{0} {9}/* directive=12 */{0} {5}@{12}directive {5}{{6} {5}}{0} {9}/* doublestring=13 */{0} {1}* {5}{{7} font-family{5}:{8} {13}"doublestring"{5};{6} {5}}{0} {9}/* singlestring=14 */{0} {1}* {5}{{7} font-family{5}:{8} {14}'singlestring'{5};{6} {5}}{0} {9}/* identifier2=15 */{0} {1}* {5}{{15} identifier2{5}:{8} 0{5}}{0} {9}/* attribute=16 */{0} {5}[{16}attribute{5}]{1} {5}{}{0} {9}/* identifier3=17 */{0} {1}* {5}{{17} identifier3{5}:{8} 0{5}}{0} {9}/* pseudoelement=18 */{0} {5}::{18}pseudoelement{1} {5}{}{0} {9}/* extended_identifier=19 */{0} {1}* {5}{{19} extended_identifier{5}:{8} 0{5}}{0} {9}/* extended_pseudoclass=20 */{0} {5}:{20}extended_pseudoclass{1} {5}{}{0} {9}/* extended_pseudoelement=21 */{0} {5}::{21}extended_pseudo_element{1} {5}{}{0} {9}/* media=22 */{0} {5}@{22}media (orientation: portrait) {5}{{0} {5}}{0} {9}/* group rule=22 */{0} {5}@{22}supports ( display: flex ) {5}{{0} {1}body {5}{{7} display{5}:{8} flex{5};{6} {5}}{6} {5}}{0} {9}/* variable=23 */{0} {23}$variable{5}:{8}#428bca{5};{0} tmpok_q575y/lexilla/test/examples/css/AllStyles.css0000664000175000017500000000204414773064066022216 0ustar gusnangusnan/* Enumerate all styles: 0 to 23 */ /* comment=9 */ /* whitespace=0 */ /* */ /* tag=1 */ html/**/ {} /* class=2 */ .hidden {} /* pseudoclass=3 */ :link {} /* unknown pseudoclass=4 */ :unknown {} /* operator=5 */ # {} /* identifier=6 */ *{margin:} /* unknown identifier=7 */ *{unknown:} /* value=8 */ *{:88} /* identifier=10 */ #identifier {} /* important=11 */ * { margin: 0 ! important; } /* directive=12 */ @directive { } /* doublestring=13 */ * { font-family: "doublestring"; } /* singlestring=14 */ * { font-family: 'singlestring'; } /* identifier2=15 */ * { identifier2: 0} /* attribute=16 */ [attribute] {} /* identifier3=17 */ * { identifier3: 0} /* pseudoelement=18 */ ::pseudoelement {} /* extended_identifier=19 */ * { extended_identifier: 0} /* extended_pseudoclass=20 */ :extended_pseudoclass {} /* extended_pseudoelement=21 */ ::extended_pseudo_element {} /* media=22 */ @media (orientation: portrait) { } /* group rule=22 */ @supports ( display: flex ) { body { display: flex; } } /* variable=23 */ $variable:#428bca; tmpok_q575y/lexilla/test/examples/nix/0000775000175000017500000000000014773064066017576 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/nix/SciTE.properties0000664000175000017500000000227014773064066022664 0ustar gusnangusnanlexer.*.nix=nix fold=1 keywords.*.nix=assert else if in inherit let or rec then with keywords2.*.nix=false null true keywords3.*.nix=abort add addDrvOutputDependencies all any attrNames attrValues baseNameOf bitAnd bitOr bitXor break builtins catAttrs ceil compareVersions concatLists concatMap concatStringsSep convertHash currentSystem currentTime deepSeq derivation dirOf div elem elemAt fetchClosure fetchGit fetchTarball fetchTree fetchurl filter filterSource findFile flakeRefToString floor foldl' fromJSON fromTOML functionArgs genList genericClosure getAttr getContext getEnv getFlake groupBy hasAttr hasContext hashFile hashString head import intersectAttrs isAttrs isBool isFloat isFunction isInt isList isNull isPath isString langVersion length lessThan listToAttrs map mapAttrs match mul nixPath nixVersion outputOf parseDrvName parseFlakeRef partition path pathExists placeholder readDir readFile readFileType removeAttrs replaceStrings seq sort split splitVersion storeDir storePath stringLength sub substring tail throw toFile toJSON toPath toString toXML trace traceVerbose tryEval typeOf unsafeDiscardOutputDependency unsafeDiscardStringContext warn zipAttrsWith keywords4.*.nix=runCommand tmpok_q575y/lexilla/test/examples/nix/AllStyles.nix.styled0000664000175000017500000002752314773064066023546 0ustar gusnangusnan{1}# coding:utf-8 {0} {9}1{0} {7}+{0} {9}2{0} {12}let{0} {10}x{0} {7}={0} {9}1{7};{0} {10}y{0} {7}={0} {9}2{7};{0} {12}in{0} {6}x{0} {7}+{0} {6}y{0} {12}let{0} {10}x{7}={9}1{7};{10}y{7}={9}2{7};{12}in{0} {6}x{7}+{6}y{0} {7}{{0} {10}string{0} {7}={0} {3}"hello"{7};{0} {10}integer{0} {7}={0} {9}1{7};{0} {10}float{0} {7}={0} {9}3.141{7};{0} {10}bool{0} {7}={0} {13}true{7};{0} {10}null{0} {7}={0} {13}null{7};{0} {10}list{0} {7}={0} {7}[{0} {9}1{0} {3}"two"{0} {13}false{0} {7}];{0} {10}attribute-set{0} {7}={0} {7}{{0} {10}a{0} {7}={0} {3}"hello"{7};{0} {10}b{0} {7}={0} {9}2{7};{0} {10}c{0} {7}={0} {9}2.718{7};{0} {10}d{0} {7}={0} {13}false{7};{0} {7}};{0} {1}# comments are supported {7}}{0} {12}rec{0} {7}{{0} {10}one{0} {7}={0} {9}1{7};{0} {10}two{0} {7}={0} {6}one{0} {7}+{0} {9}1{7};{0} {10}three{0} {7}={0} {6}two{0} {7}+{0} {9}1{7};{0} {7}}{0} {7}{{0} {10}one{0} {7}={0} {9}1{7};{0} {10}three{0} {7}={0} {9}3{7};{0} {10}two{0} {7}={0} {9}2{7};{0} {7}}{0} {12}let{0} {10}a{0} {7}={0} {9}1{7};{0} {12}in{0} {6}a{0} {7}+{0} {6}a{0} {12}let{0} {10}b{0} {7}={0} {6}a{0} {7}+{0} {9}1{7};{0} {10}a{0} {7}={0} {9}1{7};{0} {12}in{0} {6}a{0} {7}+{0} {6}b{0} {7}{{0} {10}a{0} {7}={0} {12}let{0} {10}x{0} {7}={0} {9}1{7};{0} {12}in{0} {6}x{7};{0} {10}b{0} {7}={0} {6}x{7};{0} {7}}{0} {12}let{0} {10}attrset{0} {7}={0} {7}{{0} {10}x{0} {7}={0} {9}1{7};{0} {7}};{0} {12}in{0} {6}attrset{7}.{6}x{0} {12}let{0} {10}attrset{0} {7}={0} {7}{{0} {10}a{0} {7}={0} {7}{{0} {10}b{0} {7}={0} {7}{{0} {10}c{0} {7}={0} {9}1{7};{0} {7}};{0} {7}};{0} {7}};{0} {12}in{0} {6}attrset{7}.{6}a{7}.{6}b{7}.{6}c{0} {7}{{0} {6}a{7}.{6}b{7}.{10}c{0} {7}={0} {9}1{7};{0} {7}}{0} {12}let{0} {10}a{0} {7}={0} {7}{{0} {10}x{0} {7}={0} {9}1{7};{0} {10}y{0} {7}={0} {9}2{7};{0} {10}z{0} {7}={0} {9}3{7};{0} {7}};{0} {12}in{0} {12}with{0} {6}a{7};{0} {7}[{0} {6}x{0} {6}y{0} {6}z{0} {7}]{0} {12}let{0} {10}x{0} {7}={0} {9}1{7};{0} {10}y{0} {7}={0} {9}2{7};{0} {12}in{0} {7}{{0} {12}inherit{0} {6}x{0} {6}y{7};{0} {7}}{0} {12}let{0} {10}a{0} {7}={0} {7}{{0} {10}x{0} {7}={0} {9}1{7};{0} {10}y{0} {7}={0} {9}2{7};{0} {7}};{0} {12}in{0} {7}{{0} {12}inherit{0} {7}({6}a{7}){0} {6}x{0} {6}y{7};{0} {7}}{0} {12}let{0} {12}inherit{0} {7}({{0} {10}x{0} {7}={0} {9}1{7};{0} {10}y{0} {7}={0} {9}2{7};{0} {7}}){0} {6}x{0} {6}y{7};{0} {12}in{0} {7}[{0} {6}x{0} {6}y{0} {7}]{0} {12}let{0} {10}name{0} {7}={0} {3}"Nix{8}${}{3}"{7};{0} {12}in{0} {3}"hello {8}${{6}name{8}}{3}"{0} {10}graphviz{0} {7}={0} {7}({14}import{0} {11}../tools/graphics/graphviz{7}){0} {7}{{0} {12}inherit{0} {14}fetchurl{0} {6}stdenv{0} {6}libpng{0} {6}libjpeg{0} {6}expat{0} {6}x11{0} {6}yacc{7};{0} {12}inherit{0} {7}({6}xorg{7}){0} {6}libXaw{7};{0} {7}};{0} {12}let{0} {10}negate{0} {7}={0} {6}x{7}:{0} {7}!{6}x{7};{0} {10}concat{0} {7}={0} {6}x{7}:{0} {6}y{7}:{0} {6}x{0} {7}+{0} {6}y{7};{0} {12}in{0} {12}if{0} {6}negate{0} {13}true{0} {12}then{0} {6}concat{0} {3}"foo"{0} {3}"bar"{0} {12}else{0} {3}""{0} {1}# A number # Equals 1 + 1 # asd {0} {2}/* /* Block comments can span multiple lines. */{0} {3}"hello"{0} {3}"hello"{0} {2}/* /* nope */{0} {9}1{0} {14}map{0} {7}({6}concat{0} {3}"foo"{7}){0} {7}[{0} {3}"bar"{0} {3}"bla"{0} {3}"abc"{0} {7}]{0} {7}{{0} {6}localServer{0} {7}?{0} {13}false{0} {7},{0} {6}httpServer{0} {7}?{0} {13}false{0} {7},{0} {6}sslSupport{0} {7}?{0} {13}false{0} {7},{0} {6}pythonBindings{0} {7}?{0} {13}false{0} {7},{0} {6}javaSwigBindings{0} {7}?{0} {13}false{0} {7},{0} {6}javahlBindings{0} {7}?{0} {13}false{0} {7},{0} {6}stdenv{7},{0} {14}fetchurl{0} {7},{0} {6}openssl{0} {7}?{0} {13}null{7},{0} {6}httpd{0} {7}?{0} {13}null{7},{0} {6}db4{0} {7}?{0} {13}null{7},{0} {6}expat{7},{0} {6}swig{0} {7}?{0} {13}null{7},{0} {6}j2sdk{0} {7}?{0} {13}null{0} {7}}:{0} {12}assert{0} {6}localServer{0} {7}->{0} {6}db4{0} {7}!={0} {13}null{7};{0} {12}assert{0} {6}httpServer{0} {7}->{0} {6}httpd{0} {7}!={0} {13}null{0} {7}&&{0} {6}httpd{7}.{10}expat{0} {7}=={0} {6}expat{7};{0} {12}assert{0} {6}sslSupport{0} {7}->{0} {6}openssl{0} {7}!={0} {13}null{0} {7}&&{0} {7}({6}httpServer{0} {7}->{0} {6}httpd{7}.{10}openssl{0} {7}=={0} {6}openssl{7});{0} {12}assert{0} {6}pythonBindings{0} {7}->{0} {6}swig{0} {7}!={0} {13}null{0} {7}&&{0} {6}swig{7}.{6}pythonSupport{7};{0} {12}assert{0} {6}javaSwigBindings{0} {7}->{0} {6}swig{0} {7}!={0} {13}null{0} {7}&&{0} {6}swig{7}.{6}javaSupport{7};{0} {12}assert{0} {6}javahlBindings{0} {7}->{0} {6}j2sdk{0} {7}!={0} {13}null{7};{0} {6}stdenv{7}.{6}mkDerivation{0} {7}{{0} {10}name{0} {7}={0} {3}"subversion-1.1.1"{7};{0} {10}openssl{0} {7}={0} {12}if{0} {6}sslSupport{0} {12}then{0} {6}openssl{0} {12}else{0} {13}null{7};{0} {7}}{0} {10}configureFlags{0} {7}={0} {4}'' -system-zlib -system-libpng -system-libjpeg {8}${{12}if{0} {6}openglSupport{0} {12}then{0} {4}''-dlopen-opengl -L{8}${{6}mesa{8}}{4}/lib -I{8}${{6}mesa{8}}{4}/include -L{8}${{6}libXmu{8}}{4}/lib -I{8}${{6}libXmu{8}}{4}/include''{0} {12}else{0} {3}""{8}}{4} {8}${{12}if{0} {6}threadSupport{0} {12}then{0} {3}"-thread"{0} {12}else{0} {3}"-no-thread"{8}}{4} ''{7};{0} {12}let{0} {10}a{0} {7}={0} {3}"no"{7};{0} {6}a{7}.{6}b{7}.{6}c{7}.{10}d{0} {7}={0} {3}"foo"{0} {12}in{0} {3}"{8}${{6}a{0} {7}+{0} {3}" {8}${{6}a{0} {7}+{0} {3}" {8}${{6}a{8}}{3}"{8}}{3}"{8}}{3}"{0} {12}let{0} {10}out{0} {7}={0} {3}"Nix"{7};{0} {12}in{0} {3}"echo {8}${{6}out{8}}{3} > $out"{0} {11}{0} {4}'' multi {5}''${4}{} {5}'''{4} line {5}''\n{4} string ''{0} {4}'' one two three ''{0} {6}x{7}:{0} {6}x{0} {7}+{0} {9}1{0} {6}x{7}:{0} {6}y{7}:{0} {6}x{0} {7}+{0} {6}y{0} {7}{{0} {6}a{7},{0} {6}b{0} {7}}:{0} {6}a{0} {7}+{0} {6}b{0} {7}{{0} {6}a{7},{0} {6}b{0} {7}?{0} {9}0{0} {7}}:{0} {6}a{0} {7}+{0} {6}b{0} {7}{{0} {6}a{7},{0} {6}b{7},{0} {7}...}:{0} {6}a{0} {7}+{0} {6}b{0} {6}args{7}@{{0} {6}a{7},{0} {6}b{7},{0} {7}...{0} {7}}:{0} {6}a{0} {7}+{0} {6}b{0} {7}+{0} {6}args{7}.{6}c{0} {7}{{0} {6}a{7},{0} {6}b{7},{0} {7}...{0} {7}}@{6}args{7}:{0} {6}a{0} {7}+{0} {6}b{0} {7}+{0} {6}args{7}.{6}c{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}x{0} {7}+{0} {9}1{7};{0} {12}in{0} {6}f{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}x{0} {7}+{0} {9}1{7};{0} {12}in{0} {6}f{0} {9}1{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}x{7}.{6}a{7};{0} {10}v{0} {7}={0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {7}};{0} {12}in{0} {6}f{0} {6}v{0} {7}({6}x{7}:{0} {6}x{0} {7}+{0} {9}1{7}){0} {9}1{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}x{0} {7}+{0} {9}1{7};{0} {10}a{0} {7}={0} {9}1{7};{0} {12}in{0} {7}[{0} {7}({6}f{0} {6}a{7}){0} {7}]{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}x{0} {7}+{0} {9}1{7};{0} {10}a{0} {7}={0} {9}1{7};{0} {12}in{0} {7}[{0} {6}f{0} {6}a{0} {7}]{0} {12}let{0} {10}f{0} {7}={0} {6}x{7}:{0} {6}y{7}:{0} {6}x{0} {7}+{0} {6}y{7};{0} {12}in{0} {6}f{0} {9}1{0} {9}2{0} {7}{{6}a{7},{0} {6}b{7}}:{0} {6}a{0} {7}+{0} {6}b{0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{7},{0} {6}b{7}}:{0} {6}a{0} {7}+{0} {6}b{7};{0} {12}in{0} {6}f{0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {10}b{0} {7}={0} {9}2{7};{0} {7}}{0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{7},{0} {6}b{7}}:{0} {6}a{0} {7}+{0} {6}b{7};{0} {12}in{0} {6}f{0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {10}b{0} {7}={0} {9}2{7};{0} {10}c{0} {7}={0} {9}3{7};{0} {7}}{0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{7},{0} {6}b{0} {7}?{0} {9}0{7}}:{0} {6}a{0} {7}+{0} {6}b{7};{0} {12}in{0} {6}f{0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {7}}{0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{0} {7}?{0} {9}0{7},{0} {6}b{0} {7}?{0} {9}0{7}}:{0} {6}a{0} {7}+{0} {6}b{7};{0} {12}in{0} {6}f{0} {7}{{0} {7}}{0} {1}# empty attribute set {0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{7},{0} {6}b{7},{0} {7}...}:{0} {6}a{0} {7}+{0} {6}b{7};{0} {12}in{0} {6}f{0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {10}b{0} {7}={0} {9}2{7};{0} {10}c{0} {7}={0} {9}3{7};{0} {7}}{0} {7}{{6}a{7},{0} {6}b{7},{0} {7}...}@{6}args{7}:{0} {6}a{0} {7}+{0} {6}b{0} {7}+{0} {6}args{7}.{6}c{0} {6}args{7}@{{6}a{7},{0} {6}b{7},{0} {7}...}:{0} {6}a{0} {7}+{0} {6}b{0} {7}+{0} {6}args{7}.{6}c{0} {12}let{0} {10}f{0} {7}={0} {7}{{6}a{7},{0} {6}b{7},{0} {7}...}@{6}args{7}:{0} {6}a{0} {7}+{0} {6}b{0} {7}+{0} {6}args{7}.{6}c{7};{0} {12}in{0} {6}f{0} {7}{{0} {10}a{0} {7}={0} {9}1{7};{0} {10}b{0} {7}={0} {9}2{7};{0} {10}c{0} {7}={0} {9}3{7};{0} {7}}{0} {7}{{0} {6}pkgs{0} {7}?{0} {14}import{0} {11}{0} {7}{}{0} {7}}:{0} {12}let{0} {10}message{0} {7}={0} {3}"hello world"{7};{0} {12}in{0} {6}pkgs{7}.{6}mkShellNoCC{0} {7}{{0} {10}packages{0} {7}={0} {12}with{0} {6}pkgs{7};{0} {7}[{0} {6}cowsay{0} {7}];{0} {10}shellHook{0} {7}={0} {4}'' cowsay {8}${{6}message{8}}{4} ''{7};{0} {7}}{0} {7}{{0} {6}config{7},{0} {6}pkgs{7},{0} {7}...{0} {7}}:{0} {7}{{0} {10}imports{0} {7}={0} {7}[{0} {11}./hardware-configuration.nix{0} {7}];{0} {6}environment{7}.{10}systemPackages{0} {7}={0} {12}with{0} {6}pkgs{7};{0} {7}[{0} {6}git{0} {7}];{0} {1}# ... {7}}{0} {7}{{0} {6}lib{7},{0} {6}stdenv{7},{0} {14}fetchurl{0} {7}}:{0} {6}stdenv{7}.{6}mkDerivation{0} {12}rec{0} {7}{{0} {10}pname{0} {7}={0} {3}"hello"{7};{0} {10}version{0} {7}={0} {3}"2.12"{7};{0} {10}src{0} {7}={0} {14}fetchurl{0} {7}{{0} {10}url{0} {7}={0} {3}"mirror://gnu/{8}${{6}pname{8}}{3}/{8}${{6}pname{8}}{3}-{8}${{6}version{8}}{3}.tar.gz"{7};{0} {10}sha256{0} {7}={0} {3}"1ayhp9v4m4rdhjmnl2bq3cibrbqqkgjbl3s7yk2nhlh8vj3ay16g"{7};{0} {7}};{0} {10}meta{0} {7}={0} {12}with{0} {6}lib{7};{0} {7}{{0} {10}license{0} {7}={0} {6}licenses{7}.{6}gpl3Plus{7};{0} {7}};{0} {7}}{0} {7}{{0} {10}baseName{0} {7}={0} {14}baseNameOf{0} {6}name{7};{0} {10}pullImage{0} {7}={0} {12}let{0} {10}fixName{0} {7}={0} {6}name{7}:{0} {14}builtins{7}.{14}replaceStrings{0} {7}[{0} {3}"/"{0} {3}":"{0} {7}]{0} {7}[{0} {3}"-"{0} {3}"-"{0} {7}]{0} {6}name{7};{0} {12}in{0} {7}{{0} {6}imageName{0} {1}# To find the digest of an image, you can use skopeo: {0} {1}# see doc/functions.xml {0} {7},{0} {6}imageDigest{0} {7},{0} {6}sha256{0} {7},{0} {6}os{0} {7}?{0} {3}"linux"{0} {7},{0} {1}# Image architecture, defaults to the architecture of the `hostPlatform` when unset {0} {6}arch{0} {7}?{0} {6}defaultArchitecture{0} {1}# This is used to set name to the pulled image {0} {7},{0} {6}finalImageName{0} {7}?{0} {6}imageName{0} {1}# This used to set a tag to the pulled image {0} {7},{0} {6}finalImageTag{0} {7}?{0} {3}"latest"{0} {1}# This is used to disable TLS certificate verification, allowing access to http registries on (hopefully) trusted networks {0} {7},{0} {6}tlsVerify{0} {7}?{0} {13}true{0} {7},{0} {6}name{0} {7}?{0} {6}fixName{0} {3}"docker-image-{8}${{6}finalImageName{8}}{3}-{8}${{6}finalImageTag{8}}{3}.tar"{0} {7}}:{0} {15}runCommand{0} {6}name{0} {7}{{0} {12}inherit{0} {6}imageDigest{7};{0} {10}imageName{0} {7}={0} {6}finalImageName{7};{0} {10}imageTag{0} {7}={0} {6}finalImageTag{7};{0} {10}impureEnvVars{0} {7}={0} {6}lib{7}.{6}fetchers{7}.{6}proxyImpureEnvVars{7};{0} {10}outputHashMode{0} {7}={0} {3}"flat"{7};{0} {10}outputHashAlgo{0} {7}={0} {3}"sha256"{7};{0} {10}outputHash{0} {7}={0} {6}sha256{7};{0} {10}nativeBuildInputs{0} {7}={0} {7}[{0} {6}skopeo{0} {7}];{0} {10}SSL_CERT_FILE{0} {7}={0} {3}"{8}${{6}cacert{7}.{6}out{8}}{3}/etc/ssl/certs/ca-bundle.crt"{7};{0} {10}sourceURL{0} {7}={0} {3}"docker://{8}${{6}imageName{8}}{3}@{8}${{6}imageDigest{8}}{3}"{7};{0} {10}destNameTag{0} {7}={0} {3}"{8}${{6}finalImageName{8}}{3}:{8}${{6}finalImageTag{8}}{3}"{7};{0} {7}}{0} {4}'' skopeo \ --insecure-policy \ --tmpdir=$TMPDIR \ --override-os {8}${{6}os{8}}{4} \ --override-arch {8}${{6}arch{8}}{4} \ copy \ --src-tls-verify={8}${{6}lib{7}.{6}boolToString{0} {6}tlsVerify{8}}{4} \ "$sourceURL" "docker-archive://$out:$destNameTag" \ | cat # pipe through cat to force-disable progress bar ''{7};{0} {7}}{0} tmpok_q575y/lexilla/test/examples/nix/AllStyles.nix.folded0000664000175000017500000002352114773064066023471 0ustar gusnangusnan 0 400 400 # coding:utf-8 0 400 400 0 400 400 1 + 2 0 400 400 0 400 400 let 0 400 400 x = 1; 0 400 400 y = 2; 0 400 400 in x + y 0 400 400 0 400 400 let x=1;y=2;in x+y 0 400 400 2 400 401 + { 0 401 401 | string = "hello"; 0 401 401 | integer = 1; 0 401 401 | float = 3.141; 0 401 401 | bool = true; 0 401 401 | null = null; 0 401 401 | list = [ 1 "two" false ]; 2 401 402 + attribute-set = { 0 402 402 | a = "hello"; 0 402 402 | b = 2; 0 402 402 | c = 2.718; 0 402 402 | d = false; 0 402 401 | }; # comments are supported 0 401 400 | } 0 400 400 2 400 401 + rec { 0 401 401 | one = 1; 0 401 401 | two = one + 1; 0 401 401 | three = two + 1; 0 401 400 | } 0 400 400 0 400 400 { one = 1; three = 3; two = 2; } 0 400 400 0 400 400 let 0 400 400 a = 1; 0 400 400 in 0 400 400 a + a 0 400 400 0 400 400 let 0 400 400 b = a + 1; 0 400 400 a = 1; 0 400 400 in 0 400 400 a + b 0 400 400 2 400 401 + { 0 401 401 | a = let x = 1; in x; 0 401 401 | b = x; 0 401 400 | } 0 400 400 0 400 400 let 0 400 400 attrset = { x = 1; }; 0 400 400 in 0 400 400 attrset.x 0 400 400 0 400 400 let 0 400 400 attrset = { a = { b = { c = 1; }; }; }; 0 400 400 in 0 400 400 attrset.a.b.c 0 400 400 0 400 400 { a.b.c = 1; } 0 400 400 0 400 400 let 2 400 401 + a = { 0 401 401 | x = 1; 0 401 401 | y = 2; 0 401 401 | z = 3; 0 401 400 | }; 0 400 400 in 0 400 400 with a; [ x y z ] 0 400 400 0 400 400 let 0 400 400 x = 1; 0 400 400 y = 2; 0 400 400 in 2 400 401 + { 0 401 401 | inherit x y; 0 401 400 | } 0 400 400 0 400 400 let 0 400 400 a = { x = 1; y = 2; }; 0 400 400 in 2 400 401 + { 0 401 401 | inherit (a) x y; 0 401 400 | } 0 400 400 0 400 400 let 0 400 400 inherit ({ x = 1; y = 2; }) x y; 0 400 400 in [ x y ] 0 400 400 0 400 400 let 0 400 400 name = "Nix${}"; 0 400 400 in 0 400 400 "hello ${name}" 0 400 400 2 400 401 + graphviz = (import ../tools/graphics/graphviz) { 0 401 401 | inherit fetchurl stdenv libpng libjpeg expat x11 yacc; 0 401 401 | inherit (xorg) libXaw; 0 401 400 | }; 0 400 400 0 400 400 let negate = x: !x; 0 400 400 concat = x: y: x + y; 0 400 400 in if negate true then concat "foo" "bar" else "" 0 400 400 0 400 400 # A number 0 400 400 # Equals 1 + 1 0 400 400 # asd 0 400 400 2 400 401 + /* /* 0 401 401 | Block comments 0 401 401 | can span multiple lines. 0 401 400 | */ "hello" 0 400 400 "hello" 0 400 400 0 400 400 /* /* nope */ 1 0 400 400 0 400 400 map (concat "foo") [ "bar" "bla" "abc" ] 0 400 400 2 400 401 + { localServer ? false 0 401 401 | , httpServer ? false 0 401 401 | , sslSupport ? false 0 401 401 | , pythonBindings ? false 0 401 401 | , javaSwigBindings ? false 0 401 401 | , javahlBindings ? false 0 401 401 | , stdenv, fetchurl 0 401 401 | , openssl ? null, httpd ? null, db4 ? null, expat, swig ? null, j2sdk ? null 0 401 400 | }: 0 400 400 0 400 400 assert localServer -> db4 != null; 0 400 400 assert httpServer -> httpd != null && httpd.expat == expat; 0 400 400 assert sslSupport -> openssl != null && (httpServer -> httpd.openssl == openssl); 0 400 400 assert pythonBindings -> swig != null && swig.pythonSupport; 0 400 400 assert javaSwigBindings -> swig != null && swig.javaSupport; 0 400 400 assert javahlBindings -> j2sdk != null; 0 400 400 2 400 401 + stdenv.mkDerivation { 0 401 401 | name = "subversion-1.1.1"; 0 401 401 | openssl = if sslSupport then openssl else null; 0 401 400 | } 0 400 400 2 400 401 + configureFlags = '' 0 401 401 | -system-zlib -system-libpng -system-libjpeg 2 401 403 + ${if openglSupport then ''-dlopen-opengl 0 403 403 | -L${mesa}/lib -I${mesa}/include 0 403 401 | -L${libXmu}/lib -I${libXmu}/include'' else ""} 0 401 401 | ${if threadSupport then "-thread" else "-no-thread"} 0 401 400 | ''; 0 400 400 0 400 400 let 0 400 400 a = "no"; 0 400 400 a.b.c.d = "foo" 0 400 400 in 0 400 400 "${a + " ${a + " ${a}"}"}" 0 400 400 0 400 400 let 0 400 400 out = "Nix"; 0 400 400 in 0 400 400 "echo ${out} > $out" 0 400 400 0 400 400 0 400 400 2 400 401 + '' 0 401 401 | multi 0 401 401 | ''${} 0 401 401 | ''' 0 401 401 | line 0 401 401 | ''\n 0 401 401 | string 0 401 400 | '' 0 400 400 2 400 401 + '' 0 401 401 | one 0 401 401 | two 0 401 401 | three 0 401 400 | '' 0 400 400 0 400 400 x: x + 1 0 400 400 0 400 400 x: y: x + y 0 400 400 0 400 400 { a, b }: a + b 0 400 400 0 400 400 { a, b ? 0 }: a + b 0 400 400 0 400 400 { a, b, ...}: a + b 0 400 400 0 400 400 args@{ a, b, ... }: a + b + args.c 0 400 400 0 400 400 { a, b, ... }@args: a + b + args.c 0 400 400 0 400 400 let 0 400 400 f = x: x + 1; 0 400 400 in f 0 400 400 0 400 400 let 0 400 400 f = x: x + 1; 0 400 400 in f 1 0 400 400 0 400 400 let 0 400 400 f = x: x.a; 0 400 400 v = { a = 1; }; 0 400 400 in 0 400 400 f v 0 400 400 0 400 400 (x: x + 1) 1 0 400 400 0 400 400 let 0 400 400 f = x: x + 1; 0 400 400 a = 1; 0 400 400 in [ (f a) ] 0 400 400 0 400 400 let 0 400 400 f = x: x + 1; 0 400 400 a = 1; 0 400 400 in [ f a ] 0 400 400 0 400 400 let 0 400 400 f = x: y: x + y; 0 400 400 in 0 400 400 f 1 2 0 400 400 0 400 400 {a, b}: a + b 0 400 400 0 400 400 let 0 400 400 f = {a, b}: a + b; 0 400 400 in 0 400 400 f { a = 1; b = 2; } 0 400 400 0 400 400 let 0 400 400 f = {a, b}: a + b; 0 400 400 in 0 400 400 f { a = 1; b = 2; c = 3; } 0 400 400 0 400 400 let 0 400 400 f = {a, b ? 0}: a + b; 0 400 400 in 0 400 400 f { a = 1; } 0 400 400 0 400 400 let 0 400 400 f = {a ? 0, b ? 0}: a + b; 0 400 400 in 0 400 400 f { } # empty attribute set 0 400 400 0 400 400 let 0 400 400 f = {a, b, ...}: a + b; 0 400 400 in 0 400 400 f { a = 1; b = 2; c = 3; } 0 400 400 0 400 400 {a, b, ...}@args: a + b + args.c 0 400 400 0 400 400 args@{a, b, ...}: a + b + args.c 0 400 400 0 400 400 let 0 400 400 f = {a, b, ...}@args: a + b + args.c; 0 400 400 in 0 400 400 f { a = 1; b = 2; c = 3; } 0 400 400 0 400 400 { pkgs ? import {} }: 0 400 400 let 0 400 400 message = "hello world"; 0 400 400 in 2 400 401 + pkgs.mkShellNoCC { 0 401 401 | packages = with pkgs; [ cowsay ]; 2 401 402 + shellHook = '' 0 402 402 | cowsay ${message} 0 402 401 | ''; 0 401 400 | } 0 400 400 2 400 401 + { config, pkgs, ... }: { 0 401 401 | 0 401 401 | imports = [ ./hardware-configuration.nix ]; 0 401 401 | 0 401 401 | environment.systemPackages = with pkgs; [ git ]; 0 401 401 | 0 401 401 | # ... 0 401 400 | } 0 400 400 0 400 400 { lib, stdenv, fetchurl }: 0 400 400 2 400 401 + stdenv.mkDerivation rec { 0 401 401 | 0 401 401 | pname = "hello"; 0 401 401 | 0 401 401 | version = "2.12"; 0 401 401 | 2 401 402 + src = fetchurl { 0 402 402 | url = "mirror://gnu/${pname}/${pname}-${version}.tar.gz"; 0 402 402 | sha256 = "1ayhp9v4m4rdhjmnl2bq3cibrbqqkgjbl3s7yk2nhlh8vj3ay16g"; 0 402 401 | }; 0 401 401 | 2 401 402 + meta = with lib; { 0 402 402 | license = licenses.gpl3Plus; 0 402 401 | }; 0 401 401 | 0 401 400 | } 0 400 400 2 400 401 + { 0 401 401 | baseName = baseNameOf name; 0 401 401 | 0 401 401 | pullImage = 0 401 401 | let 0 401 401 | fixName = name: builtins.replaceStrings [ "/" ":" ] [ "-" "-" ] name; 0 401 401 | in 2 401 402 + { imageName 0 402 402 | # To find the digest of an image, you can use skopeo: 0 402 402 | # see doc/functions.xml 0 402 402 | , imageDigest 0 402 402 | , sha256 0 402 402 | , os ? "linux" 0 402 402 | , # Image architecture, defaults to the architecture of the `hostPlatform` when unset 0 402 402 | arch ? defaultArchitecture 0 402 402 | # This is used to set name to the pulled image 0 402 402 | , finalImageName ? imageName 0 402 402 | # This used to set a tag to the pulled image 0 402 402 | , finalImageTag ? "latest" 0 402 402 | # This is used to disable TLS certificate verification, allowing access to http registries on (hopefully) trusted networks 0 402 402 | , tlsVerify ? true 0 402 402 | 0 402 402 | , name ? fixName "docker-image-${finalImageName}-${finalImageTag}.tar" 0 402 401 | }: 0 401 401 | 0 401 401 | runCommand name 2 401 402 + { 0 402 402 | inherit imageDigest; 0 402 402 | imageName = finalImageName; 0 402 402 | imageTag = finalImageTag; 0 402 402 | impureEnvVars = lib.fetchers.proxyImpureEnvVars; 0 402 402 | outputHashMode = "flat"; 0 402 402 | outputHashAlgo = "sha256"; 0 402 402 | outputHash = sha256; 0 402 402 | 0 402 402 | nativeBuildInputs = [ skopeo ]; 0 402 402 | SSL_CERT_FILE = "${cacert.out}/etc/ssl/certs/ca-bundle.crt"; 0 402 402 | 0 402 402 | sourceURL = "docker://${imageName}@${imageDigest}"; 0 402 402 | destNameTag = "${finalImageName}:${finalImageTag}"; 0 402 402 | } '' 0 402 402 | skopeo \ 0 402 402 | --insecure-policy \ 0 402 402 | --tmpdir=$TMPDIR \ 0 402 402 | --override-os ${os} \ 0 402 402 | --override-arch ${arch} \ 0 402 402 | copy \ 0 402 402 | --src-tls-verify=${lib.boolToString tlsVerify} \ 0 402 402 | "$sourceURL" "docker-archive://$out:$destNameTag" \ 0 402 402 | | cat # pipe through cat to force-disable progress bar 0 402 401 | ''; 0 401 401 | 0 401 400 | } 0 400 0 tmpok_q575y/lexilla/test/examples/nix/AllStyles.nix0000664000175000017500000001261314773064066022235 0ustar gusnangusnan# coding:utf-8 1 + 2 let x = 1; y = 2; in x + y let x=1;y=2;in x+y { string = "hello"; integer = 1; float = 3.141; bool = true; null = null; list = [ 1 "two" false ]; attribute-set = { a = "hello"; b = 2; c = 2.718; d = false; }; # comments are supported } rec { one = 1; two = one + 1; three = two + 1; } { one = 1; three = 3; two = 2; } let a = 1; in a + a let b = a + 1; a = 1; in a + b { a = let x = 1; in x; b = x; } let attrset = { x = 1; }; in attrset.x let attrset = { a = { b = { c = 1; }; }; }; in attrset.a.b.c { a.b.c = 1; } let a = { x = 1; y = 2; z = 3; }; in with a; [ x y z ] let x = 1; y = 2; in { inherit x y; } let a = { x = 1; y = 2; }; in { inherit (a) x y; } let inherit ({ x = 1; y = 2; }) x y; in [ x y ] let name = "Nix${}"; in "hello ${name}" graphviz = (import ../tools/graphics/graphviz) { inherit fetchurl stdenv libpng libjpeg expat x11 yacc; inherit (xorg) libXaw; }; let negate = x: !x; concat = x: y: x + y; in if negate true then concat "foo" "bar" else "" # A number # Equals 1 + 1 # asd /* /* Block comments can span multiple lines. */ "hello" "hello" /* /* nope */ 1 map (concat "foo") [ "bar" "bla" "abc" ] { localServer ? false , httpServer ? false , sslSupport ? false , pythonBindings ? false , javaSwigBindings ? false , javahlBindings ? false , stdenv, fetchurl , openssl ? null, httpd ? null, db4 ? null, expat, swig ? null, j2sdk ? null }: assert localServer -> db4 != null; assert httpServer -> httpd != null && httpd.expat == expat; assert sslSupport -> openssl != null && (httpServer -> httpd.openssl == openssl); assert pythonBindings -> swig != null && swig.pythonSupport; assert javaSwigBindings -> swig != null && swig.javaSupport; assert javahlBindings -> j2sdk != null; stdenv.mkDerivation { name = "subversion-1.1.1"; openssl = if sslSupport then openssl else null; } configureFlags = '' -system-zlib -system-libpng -system-libjpeg ${if openglSupport then ''-dlopen-opengl -L${mesa}/lib -I${mesa}/include -L${libXmu}/lib -I${libXmu}/include'' else ""} ${if threadSupport then "-thread" else "-no-thread"} ''; let a = "no"; a.b.c.d = "foo" in "${a + " ${a + " ${a}"}"}" let out = "Nix"; in "echo ${out} > $out" '' multi ''${} ''' line ''\n string '' '' one two three '' x: x + 1 x: y: x + y { a, b }: a + b { a, b ? 0 }: a + b { a, b, ...}: a + b args@{ a, b, ... }: a + b + args.c { a, b, ... }@args: a + b + args.c let f = x: x + 1; in f let f = x: x + 1; in f 1 let f = x: x.a; v = { a = 1; }; in f v (x: x + 1) 1 let f = x: x + 1; a = 1; in [ (f a) ] let f = x: x + 1; a = 1; in [ f a ] let f = x: y: x + y; in f 1 2 {a, b}: a + b let f = {a, b}: a + b; in f { a = 1; b = 2; } let f = {a, b}: a + b; in f { a = 1; b = 2; c = 3; } let f = {a, b ? 0}: a + b; in f { a = 1; } let f = {a ? 0, b ? 0}: a + b; in f { } # empty attribute set let f = {a, b, ...}: a + b; in f { a = 1; b = 2; c = 3; } {a, b, ...}@args: a + b + args.c args@{a, b, ...}: a + b + args.c let f = {a, b, ...}@args: a + b + args.c; in f { a = 1; b = 2; c = 3; } { pkgs ? import {} }: let message = "hello world"; in pkgs.mkShellNoCC { packages = with pkgs; [ cowsay ]; shellHook = '' cowsay ${message} ''; } { config, pkgs, ... }: { imports = [ ./hardware-configuration.nix ]; environment.systemPackages = with pkgs; [ git ]; # ... } { lib, stdenv, fetchurl }: stdenv.mkDerivation rec { pname = "hello"; version = "2.12"; src = fetchurl { url = "mirror://gnu/${pname}/${pname}-${version}.tar.gz"; sha256 = "1ayhp9v4m4rdhjmnl2bq3cibrbqqkgjbl3s7yk2nhlh8vj3ay16g"; }; meta = with lib; { license = licenses.gpl3Plus; }; } { baseName = baseNameOf name; pullImage = let fixName = name: builtins.replaceStrings [ "/" ":" ] [ "-" "-" ] name; in { imageName # To find the digest of an image, you can use skopeo: # see doc/functions.xml , imageDigest , sha256 , os ? "linux" , # Image architecture, defaults to the architecture of the `hostPlatform` when unset arch ? defaultArchitecture # This is used to set name to the pulled image , finalImageName ? imageName # This used to set a tag to the pulled image , finalImageTag ? "latest" # This is used to disable TLS certificate verification, allowing access to http registries on (hopefully) trusted networks , tlsVerify ? true , name ? fixName "docker-image-${finalImageName}-${finalImageTag}.tar" }: runCommand name { inherit imageDigest; imageName = finalImageName; imageTag = finalImageTag; impureEnvVars = lib.fetchers.proxyImpureEnvVars; outputHashMode = "flat"; outputHashAlgo = "sha256"; outputHash = sha256; nativeBuildInputs = [ skopeo ]; SSL_CERT_FILE = "${cacert.out}/etc/ssl/certs/ca-bundle.crt"; sourceURL = "docker://${imageName}@${imageDigest}"; destNameTag = "${finalImageName}:${finalImageTag}"; } '' skopeo \ --insecure-policy \ --tmpdir=$TMPDIR \ --override-os ${os} \ --override-arch ${arch} \ copy \ --src-tls-verify=${lib.boolToString tlsVerify} \ "$sourceURL" "docker-archive://$out:$destNameTag" \ | cat # pipe through cat to force-disable progress bar ''; } tmpok_q575y/lexilla/test/examples/nim/0000775000175000017500000000000014773064066017563 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/nim/x.nim0000664000175000017500000000140214773064066020534 0ustar gusnangusnan# Tests for Nim let s = "foobar" # Feature #1260 {.ident.} stdin.readLine.split.map(parseInt).max.`$`.echo(" is the maximum!") # Feature #1261 # IsFuncName("proc") so style ticks as SCE_NIM_FUNCNAME: proc `$` (x: myDataType): string = ... # Style ticks as SCE_NIM_BACKTICKS: if `==`( `+`(3,4),7): echo "True" # Feature #1262 # Standard raw string identifier: let standardDoubleLitRawStr = R"A raw string\" let standardTripleLitRawStr = R"""A triple-double raw string\"""" # Style of 'customIdent' is determined by lexer.nim.raw.strings.highlight.ident. 16 if false, 6 or 10 if true let customDoubleLitRawStr = customIdent"A string\" let customTripleLitRawStr = customIdent"""A triple-double raw string\"""" # Feature #1268 10_000 10__000 10_ 1....5 1.ident 1._ident tmpok_q575y/lexilla/test/examples/nim/x.nim.styled0000664000175000017500000000227114773064066022044 0ustar gusnangusnan{3}# Tests for Nim {8}let{0} {16}s{0} {15}={0} {6}"foobar"{0} {3}# Feature #1260 {15}{.{16}ident{15}.}{0} {16}stdin{15}.{16}readLine{15}.{16}split{15}.{16}map{15}({16}parseInt{15}).{16}max{15}.{11}`$`{15}.{16}echo{15}({6}" is the maximum!"{15}){0} {3}# Feature #1261 # IsFuncName("proc") so style ticks as SCE_NIM_FUNCNAME: {8}proc{0} {12}`$`{0} {15}({16}x{15}:{0} {16}myDataType{15}):{0} {16}string{0} {15}={0} {15}...{0} {3}# Style ticks as SCE_NIM_BACKTICKS: {8}if{0} {11}`==`{15}({0} {11}`+`{15}({5}3{15},{5}4{15}),{5}7{15}):{0} {16}echo{0} {6}"True"{0} {3}# Feature #1262 # Standard raw string identifier: {8}let{0} {16}standardDoubleLitRawStr{0} {15}={0} {6}R"A raw string\"{0} {8}let{0} {16}standardTripleLitRawStr{0} {15}={0} {10}R"""A triple-double raw string\""""{0} {3}# Style of 'customIdent' is determined by lexer.nim.raw.strings.highlight.ident. 16 if false, 6 or 10 if true {8}let{0} {16}customDoubleLitRawStr{0} {15}={0} {16}customIdent{6}"A string\"{0} {8}let{0} {16}customTripleLitRawStr{0} {15}={0} {16}customIdent{10}"""A triple-double raw string\""""{0} {3}# Feature #1268 {5}10_000{0} {5}10{16}__000{0} {5}10{16}_{0} {5}1{15}....{5}5{0} {5}1{15}.{16}ident{0} {5}1{15}.{16}_ident{0} tmpok_q575y/lexilla/test/examples/nim/SciTE.properties0000664000175000017500000000006414773064066022650 0ustar gusnangusnanlexer.*.nim=nim keywords.*.nim=else end if let proc tmpok_q575y/lexilla/test/examples/nim/x.nim.folded0000664000175000017500000000217314773064066021776 0ustar gusnangusnan 1 0 0 # Tests for Nim 0 400 0 let s = "foobar" 1 400 0 1 400 0 # Feature #1260 0 400 0 {.ident.} 0 400 0 stdin.readLine.split.map(parseInt).max.`$`.echo(" is the maximum!") 1 400 0 1 400 0 # Feature #1261 1 400 0 # IsFuncName("proc") so style ticks as SCE_NIM_FUNCNAME: 0 400 0 proc `$` (x: myDataType): string = ... 1 400 0 # Style ticks as SCE_NIM_BACKTICKS: 0 400 0 if `==`( `+`(3,4),7): echo "True" 1 400 0 1 400 0 # Feature #1262 1 400 0 # Standard raw string identifier: 0 400 0 let standardDoubleLitRawStr = R"A raw string\" 0 400 0 let standardTripleLitRawStr = R"""A triple-double raw string\"""" 1 400 0 # Style of 'customIdent' is determined by lexer.nim.raw.strings.highlight.ident. 16 if false, 6 or 10 if true 0 400 0 let customDoubleLitRawStr = customIdent"A string\" 0 400 0 let customTripleLitRawStr = customIdent"""A triple-double raw string\"""" 1 400 0 1 400 0 # Feature #1268 0 400 0 10_000 0 400 0 10__000 0 400 0 10_ 0 400 0 1....5 0 400 0 1.ident 0 400 0 1._ident 1 400 0 tmpok_q575y/lexilla/test/examples/progress/0000775000175000017500000000000014773064066020644 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/progress/comment_test.p.folded0000664000175000017500000000442214773064066024764 0ustar gusnangusnan 0 400 400 //line comment 0 400 400 0 400 400 /* block comment */ 0 400 400 2 400 401 + /* block comment on 0 401 400 | multiple lines */ 0 400 400 0 400 400 /* //line comment within block comment */ 0 400 400 0 400 400 // /*block comment within line comment */ 0 400 400 0 400 400 // using open-block-comment symbol alone on line comment /* 0 400 400 0 400 400 /* /* nested block comment */ */ 0 400 400 0 400 400 DISPLAY "this line of code is a test". 0 400 400 DISPLAY "//this line of code is a test". 0 400 400 DISPLAY "/* this line of code is a test */". 0 400 400 0 400 400 // using close-block-comment symbol alone on line comment */ 0 400 400 0 400 400 // /* improperly closed block comment within line comment */ */ 0 400 400 2 400 401 + /* 0 401 401 | //line comment 1 in block comment 0 401 401 | //line comment 2 in block comment 0 401 401 | //line comment 3 in block comment 0 401 400 | */ 0 400 400 2 400 401 + /* 0 401 401 | block comment text 0 401 401 | //line comment text 0 401 401 | /* inner block comment text*/ 0 401 400 | */ 0 400 400 0 400 400 DISPLAY "This is a open-block-comment symbol /*". 0 400 400 DISPLAY "This is a close-block-comment symbol */". 0 400 400 0 400 400 //* line comment plus * looks like open-block-comment 0 400 400 0 400 400 0 400 400 DISPLAY "this line of code is a test". 0 400 400 2 400 401 + /*display statement within block comment 0 401 401 | DISPLAY "this is a string". 0 401 400 | */ 0 400 400 0 400 400 DISPLAY "//line comment within string". 0 400 400 0 400 400 DISPLAY "/* //line comment within block comment within string */". 0 400 400 0 400 400 /* Improperly closed block comment */ */ 0 400 400 0 400 400 DISPLAY "this line of code is a test". 0 400 400 0 400 400 DISPLAY "line comment with leading whitespace". // this is a line comment 0 400 400 DISPLAY "line comment without leading whitespace".// this is not a line comment 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 0 400 400 1 400 400 tmpok_q575y/lexilla/test/examples/progress/comment_test.p0000664000175000017500000000256714773064066023540 0ustar gusnangusnan//line comment /* block comment */ /* block comment on multiple lines */ /* //line comment within block comment */ // /*block comment within line comment */ // using open-block-comment symbol alone on line comment /* /* /* nested block comment */ */ DISPLAY "this line of code is a test". DISPLAY "//this line of code is a test". DISPLAY "/* this line of code is a test */". // using close-block-comment symbol alone on line comment */ // /* improperly closed block comment within line comment */ */ /* //line comment 1 in block comment //line comment 2 in block comment //line comment 3 in block comment */ /* block comment text //line comment text /* inner block comment text*/ */ DISPLAY "This is a open-block-comment symbol /*". DISPLAY "This is a close-block-comment symbol */". //* line comment plus * looks like open-block-comment DISPLAY "this line of code is a test". /*display statement within block comment DISPLAY "this is a string". */ DISPLAY "//line comment within string". DISPLAY "/* //line comment within block comment within string */". /* Improperly closed block comment */ */ DISPLAY "this line of code is a test". DISPLAY "line comment with leading whitespace". // this is a line comment DISPLAY "line comment without leading whitespace".// this is not a line comment tmpok_q575y/lexilla/test/examples/progress/SciTE.properties0000664000175000017500000000005214773064066023726 0ustar gusnangusnanlexer.*.p=abl keywords.*.p=display fold=1 tmpok_q575y/lexilla/test/examples/progress/comment_test.p.styled0000664000175000017500000000325414773064066025035 0ustar gusnangusnan{12}//line comment {0} {10}/* block comment */{0} {10}/* block comment on multiple lines */{0} {10}/* //line comment within block comment */{0} {12}// /*block comment within line comment */ {0} {12}// using open-block-comment symbol alone on line comment /* {0} {10}/* /* nested block comment */ */{0} {2}DISPLAY{0} {3}"this line of code is a test"{6}.{0} {2}DISPLAY{0} {3}"//this line of code is a test"{6}.{0} {2}DISPLAY{0} {3}"/* this line of code is a test */"{6}.{0} {12}// using close-block-comment symbol alone on line comment */ {0} {12}// /* improperly closed block comment within line comment */ */ {0} {10}/* //line comment 1 in block comment //line comment 2 in block comment //line comment 3 in block comment */{0} {10}/* block comment text //line comment text /* inner block comment text*/ */{0} {2}DISPLAY{0} {3}"This is a open-block-comment symbol /*"{6}.{0} {2}DISPLAY{0} {3}"This is a close-block-comment symbol */"{6}.{0} {12}//* line comment plus * looks like open-block-comment {0} {2}DISPLAY{0} {3}"this line of code is a test"{6}.{0} {10}/*display statement within block comment DISPLAY "this is a string". */{0} {2}DISPLAY{0} {3}"//line comment within string"{6}.{0} {2}DISPLAY{0} {3}"/* //line comment within block comment within string */"{6}.{0} {10}/* Improperly closed block comment */{0} {6}*/{0} {2}DISPLAY{0} {3}"this line of code is a test"{6}.{0} {2}DISPLAY{0} {3}"line comment with leading whitespace"{6}.{0} {12}// this is a line comment {2}DISPLAY{0} {3}"line comment without leading whitespace"{6}.//{0} {7}this{0} {7}is{0} {7}not{0} {7}a{0} {7}line{0} {7}comment{0} tmpok_q575y/lexilla/test/examples/diff/0000775000175000017500000000000014773064066017710 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/diff/AllStyles.diff.folded0000664000175000017500000000310414773064066023710 0ustar gusnangusnan 0 400 0 Default=0 0 400 0 Default 0 400 0 0 400 0 Comment=1 0 400 0 Another comment 0 400 0 0 400 0 Command=2 diff 2 400 0 + diff -u a/cocoa/ScintillaCocoa.mm b/cocoa/ScintillaCocoa.mm 0 401 0 | 0 401 0 | Header=3 --- 2 401 0 + --- a/cocoa/ScintillaCocoa.mm 2016-12-30 14:38:22.000000000 -0600 0 402 0 | 0 402 0 | Header=3 +++ 2 401 0 + +++ b/cocoa/ScintillaCocoa.mm 2017-02-15 08:20:12.000000000 -0600 0 402 0 | 0 402 0 | Position=4 @@ 2 402 0 + @@ -388,7 +388,8 @@ 0 403 0 | 0 403 0 | - (void) idleTriggered: (NSNotification*) notification 0 403 0 | { 0 403 0 | #pragma unused(notification) 0 403 0 | 0 403 0 | Deleted=5 - 0 403 0 | - static_cast(mTarget)->IdleTimerFired(); 0 403 0 | 0 403 0 | Added=6 + 0 403 0 | + if (mTarget) 0 403 0 | + static_cast(mTarget)->IdleTimerFired(); 0 403 0 | } 0 403 0 | 0 403 0 | @end 0 403 0 | 0 403 0 | Changed=7 ! 0 403 0 | ! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; 0 403 0 | 0 403 0 | PatchAdd=8 ++ 0 403 0 | ++ styler.ColourTo(i - 1, StateToPrint); 0 403 0 | 0 403 0 | PatchDelete=9 +- 0 403 0 | +- styler.ColourTo(i - 1, StateToPrint); 0 403 0 | 0 403 0 | RemovedPatchAdd=10 -+ 0 403 0 | -+ styler.ColourTo(i - 1, StateToPrint); 0 403 0 | 0 403 0 | RemovedPatchDelete=11 -- 0 403 0 | -- styler.ColourTo(i - 1, StateToPrint); 0 403 0 | 2 400 0 + diff -u a/cocoa/ScintillaCocoa.h b/cocoa/ScintillaCocoa.h 0 401 0 | 0 400 0 tmpok_q575y/lexilla/test/examples/diff/AllStyles.diff.styled0000664000175000017500000000202614773064066023761 0ustar gusnangusnan{1}Default=0 {0} Default {1} Comment=1 Another comment Command=2 diff {2}diff -u a/cocoa/ScintillaCocoa.mm b/cocoa/ScintillaCocoa.mm {1} Header=3 --- {3}--- a/cocoa/ScintillaCocoa.mm 2016-12-30 14:38:22.000000000 -0600 {1} Header=3 +++ {3}+++ b/cocoa/ScintillaCocoa.mm 2017-02-15 08:20:12.000000000 -0600 {1} Position=4 @@ {4}@@ -388,7 +388,8 @@ {1} {0} - (void) idleTriggered: (NSNotification*) notification { #pragma unused(notification) {1} Deleted=5 - {5}- static_cast(mTarget)->IdleTimerFired(); {1} Added=6 + {6}+ if (mTarget) + static_cast(mTarget)->IdleTimerFired(); {0} } @end {1} Changed=7 ! {7}! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; {1} PatchAdd=8 ++ {8}++ styler.ColourTo(i - 1, StateToPrint); {1} PatchDelete=9 +- {9}+- styler.ColourTo(i - 1, StateToPrint); {1} RemovedPatchAdd=10 -+ {10}-+ styler.ColourTo(i - 1, StateToPrint); {1} RemovedPatchDelete=11 -- {11}-- styler.ColourTo(i - 1, StateToPrint); {1} {2}diff -u a/cocoa/ScintillaCocoa.h b/cocoa/ScintillaCocoa.h {1} tmpok_q575y/lexilla/test/examples/diff/LongLine.diff0000664000175000017500000000200414773064066022245 0ustar gusnangusnan+A 1026-byte line is longer than 1024-byte buffer but doesn't cause problems as diff state determine by short line prefix 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456 tmpok_q575y/lexilla/test/examples/diff/LongLine.diff.styled0000664000175000017500000000201214773064066023547 0ustar gusnangusnan{6}+A 1026-byte line is longer than 1024-byte buffer but doesn't cause problems as diff state determine by short line prefix 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456 {1} tmpok_q575y/lexilla/test/examples/diff/SciTE.properties0000664000175000017500000000003114773064066022767 0ustar gusnangusnanlexer.*.diff=diff fold=1 tmpok_q575y/lexilla/test/examples/diff/AllStyles.diff0000664000175000017500000000167214773064066022464 0ustar gusnangusnanDefault=0 Default Comment=1 Another comment Command=2 diff diff -u a/cocoa/ScintillaCocoa.mm b/cocoa/ScintillaCocoa.mm Header=3 --- --- a/cocoa/ScintillaCocoa.mm 2016-12-30 14:38:22.000000000 -0600 Header=3 +++ +++ b/cocoa/ScintillaCocoa.mm 2017-02-15 08:20:12.000000000 -0600 Position=4 @@ @@ -388,7 +388,8 @@ - (void) idleTriggered: (NSNotification*) notification { #pragma unused(notification) Deleted=5 - - static_cast(mTarget)->IdleTimerFired(); Added=6 + + if (mTarget) + static_cast(mTarget)->IdleTimerFired(); } @end Changed=7 ! ! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; PatchAdd=8 ++ ++ styler.ColourTo(i - 1, StateToPrint); PatchDelete=9 +- +- styler.ColourTo(i - 1, StateToPrint); RemovedPatchAdd=10 -+ -+ styler.ColourTo(i - 1, StateToPrint); RemovedPatchDelete=11 -- -- styler.ColourTo(i - 1, StateToPrint); diff -u a/cocoa/ScintillaCocoa.h b/cocoa/ScintillaCocoa.h tmpok_q575y/lexilla/test/examples/diff/LongLine.diff.folded0000664000175000017500000000205314773064066023505 0ustar gusnangusnan 0 400 0 +A 1026-byte line is longer than 1024-byte buffer but doesn't cause problems as diff state determine by short line prefix 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456 0 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/errorlist/0000775000175000017500000000000014773064066021025 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/errorlist/AllStyles.err0000664000175000017500000000530114773064066023452 0ustar gusnangusnanDefault 0 Some text in default Python Error 1 File "x.err", line 2 Gcc Error 2, Find In Files Match 21 ScintillaGTKAccessible.cxx:153:13: warning: Deprecated pre-processor symbol, replace with Microsoft Error 3 LexErrorList.cxx(15): fatal error C1083: Cannot open include file: 'ILexer.h': No such file or directory PlatQt.obj : error LNK2019: unresolved external symbol "class Scintilla::PRectangle __cdecl Scintilla::PixelAlign(class Scintilla::PRectangle const &,int)" (?PixelAlign@Scintilla@@YA?AVPRectangle@1@AEBV21@H@Z) referenced in function "public: virtual void __cdecl Scintilla::SurfaceImpl::FillRectangleAligned(class Scintilla::PRectangle,class Scintilla::Fill)" (?FillRectangleAligned@SurfaceImpl@Scintilla@@UEAAXVPRectangle@2@VFill@2@@Z) NMAKE : fatal error U1077: '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\bin\HostX64\x64\link.EXE"' : return code '0x460' Command 4 >pwd Borland Error 5 Error E2378 oddEven.c 16: For statement missing ; in function main() Perl Error 6 Bareword found where operator expected at LexMMIXAL.cxx line 1, near "// Scintilla" DotNET Traceback 7 at ExceptionTrace.Program.f4() in C:\Ivan\dev\exp\ExceptionTrace\Program.cs:line 18 Lua Error 8 last token read: `result' at line 40 in file `Test.lua' Ctags 9 IsAWordChar LexMMIXAL.cxx /^static inline bool IsAWordChar(const int ch) {$/;" f file: Diff Changed ! 10 ! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; Diff Addition + 11 + v142 Diff Deletion - 12 - v141 Diff Message --- 13 --- a/win32/SciTE.vcxproj Fri Jan 31 12:23:51 2020 +1100 PHP error 14 Fatal error: Call to undefined function: foo() in example.php on line 11 Essential Lahey Fortran 90 Error 15 Line 11, file c:\fortran90\codigo\demo.f90 Intel Fortran Compiler Error 16 Error 71 at (17:teste.f90) : The program unit has no name Intel Fortran Compiler v8.0 Error 17 fortcom: Error: shf.f90, line 5602: This name does not have ... Absoft Pro Fortran 90 Error 18 cf90-113 f90fe: ERROR SHF3D, File = shf.f90, Line = 1101, Column = 19 HTML Tidy 19 line 8 column 1 - Error: unexpected in Java Runtime Stack Trace 20 at MethodName>(FileName.java:33) GCC Include Path 22 In file included from /usr/include/gtk-2.0/gtk/gtkobject.h:37, GCC Pointer 25 236 | void gtk_type_init (GTypeDebugFlags debug_flags); | ^ Bash Diagnostic 26 echoer153.sh: line 22: [: missing `]' Escape Sequence 23  Escape Sequence Unknown 24  Escape Sequence Colour 40 Colour 0 is 40 Escape Sequence Colour 41 Colour 1 is 41 tmpok_q575y/lexilla/test/examples/errorlist/AllStyles.err.styled0000664000175000017500000000561514773064066024765 0ustar gusnangusnan{0}Default 0 Some text in default Python Error 1 {1} File "x.err", line 2 {0} Gcc Error 2, Find In Files Match 21 {2}ScintillaGTKAccessible.cxx:153:13:{21} warning: Deprecated pre-processor symbol, replace with {0} Microsoft Error 3 {3}LexErrorList.cxx(15): fatal error C1083: Cannot open include file: 'ILexer.h': No such file or directory {0} {3}PlatQt.obj : error LNK2019: unresolved external symbol "class Scintilla::PRectangle __cdecl Scintilla::PixelAlign(class Scintilla::PRectangle const &,int)" (?PixelAlign@Scintilla@@YA?AVPRectangle@1@AEBV21@H@Z) referenced in function "public: virtual void __cdecl Scintilla::SurfaceImpl::FillRectangleAligned(class Scintilla::PRectangle,class Scintilla::Fill)" (?FillRectangleAligned@SurfaceImpl@Scintilla@@UEAAXVPRectangle@2@VFill@2@@Z) {0} {3}NMAKE : fatal error U1077: '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\bin\HostX64\x64\link.EXE"' : return code '0x460' {0} Command 4 {4}>pwd {0} Borland Error 5 {5}Error E2378 oddEven.c 16: For statement missing ; in function main() {0} Perl Error 6 {6}Bareword found where operator expected at LexMMIXAL.cxx line 1, near "// Scintilla" {0} DotNET Traceback 7 {7} at ExceptionTrace.Program.f4() in C:\Ivan\dev\exp\ExceptionTrace\Program.cs:line 18 {0} Lua Error 8 {8}last token read: `result' at line 40 in file `Test.lua' {0} Ctags 9 {9}IsAWordChar LexMMIXAL.cxx /^static inline bool IsAWordChar(const int ch) {$/;" f file: {0} Diff Changed ! 10 {10}! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; {0} Diff Addition + 11 {11}+ v142 {0} Diff Deletion - 12 {12}- v141 {0} Diff Message --- 13 {13}--- a/win32/SciTE.vcxproj Fri Jan 31 12:23:51 2020 +1100 {0} PHP error 14 {14}Fatal error: Call to undefined function: foo() in example.php on line 11 {0} Essential Lahey Fortran 90 Error 15 {15}Line 11, file c:\fortran90\codigo\demo.f90 {0} Intel Fortran Compiler Error 16 {16}Error 71 at (17:teste.f90) : The program unit has no name {0} Intel Fortran Compiler v8.0 Error 17 {17}fortcom: Error: shf.f90, line 5602: This name does not have ... {0} Absoft Pro Fortran 90 Error 18 {18}cf90-113 f90fe: ERROR SHF3D, File = shf.f90, Line = 1101, Column = 19 {0} HTML Tidy 19 {19}line 8 column 1 - Error: unexpected in {0} Java Runtime Stack Trace 20 {20} at MethodName>(FileName.java:33) {0} GCC Include Path 22 {22}In file included from /usr/include/gtk-2.0/gtk/gtkobject.h:37, {0} GCC Pointer 25 {25} 236 | void gtk_type_init (GTypeDebugFlags debug_flags); | ^ {0} Bash Diagnostic 26 {26}echoer153.sh: line 22: [: missing `]' {0} Escape Sequence 23 {23}{0} Escape Sequence Unknown 24 {24}{0} Escape Sequence Colour 40 {23}{40}Colour 0 is 40 {0} Escape Sequence Colour 41 {23}{41}Colour 1 is 41 tmpok_q575y/lexilla/test/examples/errorlist/SciTE.properties0000664000175000017500000000032314773064066024110 0ustar gusnangusnanlexer.*.err=errorlist lexer.errorlist.value.separate=1 lexer.errorlist.escape.sequences=1 style.errorlist.23=fore:#000000,back:#FFFFFF,$(error.background) style.errorlist.25=fore:#CF008F,$(font.monospace.small) tmpok_q575y/lexilla/test/examples/errorlist/AllStyles.err.folded0000664000175000017500000001024514773064066024711 0ustar gusnangusnan 0 400 0 Default 0 0 400 0 Some text in default 0 400 0 0 400 0 0 400 0 Python Error 1 0 400 0 File "x.err", line 2 0 400 0 0 400 0 0 400 0 Gcc Error 2, Find In Files Match 21 0 400 0 ScintillaGTKAccessible.cxx:153:13: warning: Deprecated pre-processor symbol, replace with 0 400 0 0 400 0 0 400 0 Microsoft Error 3 0 400 0 LexErrorList.cxx(15): fatal error C1083: Cannot open include file: 'ILexer.h': No such file or directory 0 400 0 0 400 0 PlatQt.obj : error LNK2019: unresolved external symbol "class Scintilla::PRectangle __cdecl Scintilla::PixelAlign(class Scintilla::PRectangle const &,int)" (?PixelAlign@Scintilla@@YA?AVPRectangle@1@AEBV21@H@Z) referenced in function "public: virtual void __cdecl Scintilla::SurfaceImpl::FillRectangleAligned(class Scintilla::PRectangle,class Scintilla::Fill)" (?FillRectangleAligned@SurfaceImpl@Scintilla@@UEAAXVPRectangle@2@VFill@2@@Z) 0 400 0 0 400 0 NMAKE : fatal error U1077: '"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\bin\HostX64\x64\link.EXE"' : return code '0x460' 0 400 0 0 400 0 0 400 0 Command 4 0 400 0 >pwd 0 400 0 0 400 0 0 400 0 Borland Error 5 0 400 0 Error E2378 oddEven.c 16: For statement missing ; in function main() 0 400 0 0 400 0 0 400 0 Perl Error 6 0 400 0 Bareword found where operator expected at LexMMIXAL.cxx line 1, near "// Scintilla" 0 400 0 0 400 0 0 400 0 DotNET Traceback 7 0 400 0 at ExceptionTrace.Program.f4() in C:\Ivan\dev\exp\ExceptionTrace\Program.cs:line 18 0 400 0 0 400 0 0 400 0 Lua Error 8 0 400 0 last token read: `result' at line 40 in file `Test.lua' 0 400 0 0 400 0 0 400 0 Ctags 9 0 400 0 IsAWordChar LexMMIXAL.cxx /^static inline bool IsAWordChar(const int ch) {$/;" f file: 0 400 0 0 400 0 0 400 0 Diff Changed ! 10 0 400 0 ! GdkColor white = { 0, 0xFFFF, 0xFFFF, 0xFFFF}; 0 400 0 0 400 0 0 400 0 Diff Addition + 11 0 400 0 + v142 0 400 0 0 400 0 0 400 0 Diff Deletion - 12 0 400 0 - v141 0 400 0 0 400 0 0 400 0 Diff Message --- 13 0 400 0 --- a/win32/SciTE.vcxproj Fri Jan 31 12:23:51 2020 +1100 0 400 0 0 400 0 0 400 0 PHP error 14 0 400 0 Fatal error: Call to undefined function: foo() in example.php on line 11 0 400 0 0 400 0 0 400 0 Essential Lahey Fortran 90 Error 15 0 400 0 Line 11, file c:\fortran90\codigo\demo.f90 0 400 0 0 400 0 0 400 0 Intel Fortran Compiler Error 16 0 400 0 Error 71 at (17:teste.f90) : The program unit has no name 0 400 0 0 400 0 0 400 0 Intel Fortran Compiler v8.0 Error 17 0 400 0 fortcom: Error: shf.f90, line 5602: This name does not have ... 0 400 0 0 400 0 0 400 0 Absoft Pro Fortran 90 Error 18 0 400 0 cf90-113 f90fe: ERROR SHF3D, File = shf.f90, Line = 1101, Column = 19 0 400 0 0 400 0 0 400 0 HTML Tidy 19 0 400 0 line 8 column 1 - Error: unexpected in 0 400 0 0 400 0 0 400 0 Java Runtime Stack Trace 20 0 400 0 at MethodName>(FileName.java:33) 0 400 0 0 400 0 0 400 0 GCC Include Path 22 0 400 0 In file included from /usr/include/gtk-2.0/gtk/gtkobject.h:37, 0 400 0 0 400 0 0 400 0 GCC Pointer 25 0 400 0 236 | void gtk_type_init (GTypeDebugFlags debug_flags); 0 400 0 | ^ 0 400 0 0 400 0 0 400 0 Bash Diagnostic 26 0 400 0 echoer153.sh: line 22: [: missing `]' 0 400 0 0 400 0 0 400 0 Escape Sequence 23 0 400 0  0 400 0 0 400 0 0 400 0 Escape Sequence Unknown 24 0 400 0  0 400 0 0 400 0 0 400 0 Escape Sequence Colour 40 0 400 0 Colour 0 is 40 0 400 0 0 400 0 0 400 0 Escape Sequence Colour 41 0 400 0 Colour 1 is 41 0 400 0 tmpok_q575y/lexilla/test/examples/ruby/0000775000175000017500000000000014773064066017761 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/ruby/Issue136.rb.folded0000664000175000017500000000073114773064066023065 0ustar gusnangusnan 2 400 0 + a = {r: /\w+/, h: <256 characters but that can't be recovered from 0 400 0 #<>(value) = 1 >> value 0 401 0 | def <<(value) = 1 << value 0 401 0 | def ==(other) = true 0 401 0 | def !=(other) = true 0 401 0 | def ===(other) = true 0 401 0 | def =~(other) = true 0 401 0 | def <=>(other) = true 0 401 0 | def <(other) = true 0 401 0 | def <=(other) = true 0 401 0 | def >(other) = true 0 401 0 | def >=(other) = true 0 401 0 | # element reference and assignment 0 401 0 | def [](a, b) = puts(a + b) 2 401 0 + def []=(a, b, c) 0 402 0 | puts a + b + c 0 402 0 | end 0 401 0 | # array decomposition 0 401 0 | def dec(((a, b), c)) = puts(a + b + c) 0 401 0 | # class method 0 401 0 | def self::say(*s) = puts(s) 0 401 0 | def self.say(*s) = puts(s) 0 401 0 | # test short method name 0 401 0 | def a = 1 0 401 0 | def ab = 1 0 401 0 | end 1 400 0 0 400 0 # class method 2 400 0 + def String.hello 0 401 0 | "Hello, world!" 0 401 0 | end 0 400 0 # singleton method 0 400 0 greeting = "Hello" 2 400 0 + def greeting.broaden 0 401 0 | self + ", world!" 0 401 0 | end 0 400 0 # one line definition 0 400 0 def a(b, c) b; c end 0 400 0 # parentheses omitted 2 400 0 + def ab c 0 401 0 | puts c 0 401 0 | end 1 400 0 0 400 0 # Test folding of multi-line SCE_RB_STRING_QW 2 400 0 + puts %W( 0 401 0 | a 0 401 0 | b 0 401 0 | c 0 401 0 | ) 0 400 0 tmpok_q575y/lexilla/test/examples/ruby/225NumberDotMethod.rb.folded0000664000175000017500000000050014773064066025026 0ustar gusnangusnan 0 400 0 # Float Literals 0 400 0 12.34 0 400 0 1234e-2 0 400 0 1.234E1 0 400 0 # Range Literals 0 400 0 (1..2) 0 400 0 (2.0..3) 0 400 0 # Method on number 0 400 0 1.5.ceil 0 400 0 1ri.abs 0 400 0 3.times {|i| puts i} 0 400 0 3. times {|i| puts i} 0 400 0 tmpok_q575y/lexilla/test/examples/ruby/AllStyles.rb0000664000175000017500000000325114773064066022223 0ustar gusnangusnan# Enumerate all styles where possible: 0..31,40..45 # 30,31,40,45 are never set and 1 switches rest of file to error state #0 whitespace # # #1:error, can be set with a heredoc delimiter >256 characters but that can't be recovered from #<256 characters but that can't be recovered from{0} {2}#<>(value) = 1 >> value def <<(value) = 1 << value def ==(other) = true def !=(other) = true def ===(other) = true def =~(other) = true def <=>(other) = true def <(other) = true def <=(other) = true def >(other) = true def >=(other) = true # element reference and assignment def [](a, b) = puts(a + b) def []=(a, b, c) puts a + b + c end # array decomposition def dec(((a, b), c)) = puts(a + b + c) # class method def self::say(*s) = puts(s) def self.say(*s) = puts(s) # test short method name def a = 1 def ab = 1 end # class method def String.hello "Hello, world!" end # singleton method greeting = "Hello" def greeting.broaden self + ", world!" end # one line definition def a(b, c) b; c end # parentheses omitted def ab c puts c end # Test folding of multi-line SCE_RB_STRING_QW puts %W( a b c ) tmpok_q575y/lexilla/test/examples/ruby/Issue132.rb.folded0000664000175000017500000000020314773064066023053 0ustar gusnangusnan 0 400 0 # Bad folding when single character ')' in SCE_RB_STRING_QW #132 0 400 0 %W(#{1 + 1}) 1 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/ruby/PercentEquals124.rb0000664000175000017500000000027314773064066023312 0ustar gusnangusnan# Issue 124, disambiguating %= which may be a quote or modulo assignment # %-quoting with '=' as the quote s = %=3= puts s x = 7 # Modulo assignment, equivalent to x = x % 2 x %=2 puts x tmpok_q575y/lexilla/test/examples/vhdl/0000775000175000017500000000000014773064066017735 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/vhdl/x.vhd.folded0000664000175000017500000000424714773064066022152 0ustar gusnangusnan 0 400 400 library ieee; 0 400 400 use ieee.std_logic_1164.all; 0 400 400 use ieee.std_logic_arith.all; 1 400 400 2 400 401 + entity x is 2 401 402 + port( 0 402 402 | rst : in std_logic; 0 402 402 | clk : in std_logic; 0 402 402 | d : in std_logic; 0 402 402 | q : out std_logic_vector; 0 402 402 | a, b : in std_logic; 0 402 402 | v : out std_logic 0 402 401 | ); 0 401 400 | end x; 1 400 400 2 400 401 + architecture behavioral of x is 0 401 401 | signal q_i : std_logic_vector(q'range); 2 400 401 + begin 1 401 401 | 0 401 401 | v <= a when b = '1' else '0'; 1 401 401 | 2 401 402 + gen: for j in q'low to q'high generate 2 402 403 + gen_first: if j = q'low generate 0 403 403 | variable foo : boolean := false; 2 402 403 + begin 2 403 404 + stage1: process (rst, clk) begin 2 404 405 + if rst = '1' then 0 405 405 | q_i(j) <= '0'; 2 404 405 + elsif rising_edge(clk) then 0 405 405 | q_i(j) <= d; 2 405 406 + case a is 0 406 406 | when 1 => 0 406 406 | when 2 => 0 406 406 | when others => 0 406 405 | end case; 0 405 404 | end if; 0 404 403 | end process; 2 402 403 + else generate 2 403 404 + stages: process (rst, clk) 0 404 404 | begin 2 404 405 + if rst = '1' then 0 405 405 | q_i(j) <= '0'; 2 404 405 + elsif rising_edge(clk) then 2 405 406 + for u in 0 to 7 loop 0 406 406 | q_i(j) <= q_i(j - 1); 0 406 405 | end loop; 0 405 404 | end if; 0 404 403 | end process; 0 403 402 | end generate; 0 402 401 | end generate; 1 401 401 | 2 401 402 + L: case expression generate 0 402 402 | when choice1 => 0 402 402 | when choice2 => 0 402 401 | end generate L; 1 401 401 | 0 401 400 | end behavioral; 0 400 0 tmpok_q575y/lexilla/test/examples/vhdl/SciTE.properties0000664000175000017500000000003114773064066023014 0ustar gusnangusnanlexer.*.vhd=vhdl fold=1 tmpok_q575y/lexilla/test/examples/vhdl/x.vhd0000664000175000017500000000266514773064066020720 0ustar gusnangusnanlibrary ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; entity x is port( rst : in std_logic; clk : in std_logic; d : in std_logic; q : out std_logic_vector; a, b : in std_logic; v : out std_logic ); end x; architecture behavioral of x is signal q_i : std_logic_vector(q'range); begin v <= a when b = '1' else '0'; gen: for j in q'low to q'high generate gen_first: if j = q'low generate variable foo : boolean := false; begin stage1: process (rst, clk) begin if rst = '1' then q_i(j) <= '0'; elsif rising_edge(clk) then q_i(j) <= d; case a is when 1 => when 2 => when others => end case; end if; end process; else generate stages: process (rst, clk) begin if rst = '1' then q_i(j) <= '0'; elsif rising_edge(clk) then for u in 0 to 7 loop q_i(j) <= q_i(j - 1); end loop; end if; end process; end generate; end generate; L: case expression generate when choice1 => when choice2 => end generate L; end behavioral; tmpok_q575y/lexilla/test/examples/vhdl/x.vhd.styled0000664000175000017500000000523014773064066022212 0ustar gusnangusnan{6}library{0} {6}ieee{5};{0} {6}use{0} {6}ieee{5}.{6}std_logic_1164{5}.{6}all{5};{0} {6}use{0} {6}ieee{5}.{6}std_logic_arith{5}.{6}all{5};{0} {6}entity{0} {6}x{0} {6}is{0} {6}port{5}({0} {6}rst{0} {5}:{0} {6}in{0} {6}std_logic{5};{0} {6}clk{0} {5}:{0} {6}in{0} {6}std_logic{5};{0} {6}d{0} {5}:{0} {6}in{0} {6}std_logic{5};{0} {6}q{0} {5}:{0} {6}out{0} {6}std_logic_vector{5};{0} {6}a{5},{0} {6}b{0} {5}:{0} {6}in{0} {6}std_logic{5};{0} {6}v{0} {5}:{0} {6}out{0} {6}std_logic{0} {5});{0} {6}end{0} {6}x{5};{0} {6}architecture{0} {6}behavioral{0} {6}of{0} {6}x{0} {6}is{0} {6}signal{0} {6}q_i{0} {5}:{0} {6}std_logic_vector{5}({6}q{0}'{6}range{5});{0} {6}begin{0} {6}v{0} {5}<={0} {6}a{0} {6}when{0} {6}b{0} {5}={0} {4}'1'{0} {6}else{0} {4}'0'{5};{0} {6}gen{5}:{0} {6}for{0} {6}j{0} {6}in{0} {6}q{0}'{6}low{0} {6}to{0} {6}q{0}'{6}high{0} {6}generate{0} {6}gen_first{5}:{0} {6}if{0} {6}j{0} {5}={0} {6}q{0}'{6}low{0} {6}generate{0} {6}variable{0} {6}foo{0} {5}:{0} {6}boolean{0} {5}:={0} {6}false{5};{0} {6}begin{0} {6}stage1{5}:{0} {6}process{0} {5}({6}rst{5},{0} {6}clk{5}){0} {6}begin{0} {6}if{0} {6}rst{0} {5}={0} {4}'1'{0} {6}then{0} {6}q_i{5}({6}j{5}){0} {5}<={0} {4}'0'{5};{0} {6}elsif{0} {6}rising_edge{5}({6}clk{5}){0} {6}then{0} {6}q_i{5}({6}j{5}){0} {5}<={0} {6}d{5};{0} {6}case{0} {6}a{0} {6}is{0} {6}when{0} {3}1{0} {5}=>{0} {6}when{0} {3}2{0} {5}=>{0} {6}when{0} {6}others{0} {5}=>{0} {6}end{0} {6}case{5};{0} {6}end{0} {6}if{5};{0} {6}end{0} {6}process{5};{0} {6}else{0} {6}generate{0} {6}stages{5}:{0} {6}process{0} {5}({6}rst{5},{0} {6}clk{5}){0} {6}begin{0} {6}if{0} {6}rst{0} {5}={0} {4}'1'{0} {6}then{0} {6}q_i{5}({6}j{5}){0} {5}<={0} {4}'0'{5};{0} {6}elsif{0} {6}rising_edge{5}({6}clk{5}){0} {6}then{0} {6}for{0} {6}u{0} {6}in{0} {3}0{0} {6}to{0} {3}7{0} {6}loop{0} {6}q_i{5}({6}j{5}){0} {5}<={0} {6}q_i{5}({6}j{0} {5}-{0} {3}1{5});{0} {6}end{0} {6}loop{5};{0} {6}end{0} {6}if{5};{0} {6}end{0} {6}process{5};{0} {6}end{0} {6}generate{5};{0} {6}end{0} {6}generate{5};{0} {6}L{5}:{0} {6}case{0} {6}expression{0} {6}generate{0} {6}when{0} {6}choice1{0} {5}=>{0} {6}when{0} {6}choice2{0} {5}=>{0} {6}end{0} {6}generate{0} {6}L{5};{0} {6}end{0} {6}behavioral{5};{0} tmpok_q575y/lexilla/test/examples/powershell/0000775000175000017500000000000014773064066021164 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/powershell/Pull99Comment.ps10000664000175000017500000000005114773064066024226 0ustar gusnangusnan# End comment before \r carriage return. tmpok_q575y/lexilla/test/examples/powershell/Pull92.ps10000664000175000017500000000047114773064066022702 0ustar gusnangusnan<# Tests for PowerShell #> <# Backticks should escape in double quoted strings #> $double_quote_str_esc_1 = "`"XXX`"" $double_quote_str_esc_2 = "This `"string`" `$useses `r`n Backticks '``'" <# Backticks should be ignored in quoted strings #> $single_quote_str_esc_1 = 'XXX`' $single_quote_str_esc_2 = 'XXX```' tmpok_q575y/lexilla/test/examples/powershell/Pull99Comment.ps1.folded0000664000175000017500000000010314773064066025460 0ustar gusnangusnan 0 400 400 # End comment before \r carriage return. 0 400 0 tmpok_q575y/lexilla/test/examples/powershell/Pull92.ps1.styled0000664000175000017500000000062614773064066024207 0ustar gusnangusnan{13}<# Tests for PowerShell #>{0} {13}<# Backticks should escape in double quoted strings #>{0} {5}$double_quote_str_esc_1{0} {6}={0} {2}"`"XXX`""{0} {5}$double_quote_str_esc_2{0} {6}={0} {2}"This `"string`" `$useses `r`n Backticks '``'"{0} {13}<# Backticks should be ignored in quoted strings #>{0} {5}$single_quote_str_esc_1{0} {6}={0} {3}'XXX`'{0} {5}$single_quote_str_esc_2{0} {6}={0} {3}'XXX```'{0} tmpok_q575y/lexilla/test/examples/powershell/CharacterTruncation.ps1.styled0000664000175000017500000000047514773064066027065 0ustar gusnangusnan{1}# -*- coding: utf-8 -*-{0} {1}# Show problem with character value truncation causing U+0121 'Ä¡' (LATIN SMALL LETTER G WITH DOT ABOVE){0} {1}# to be styled as an operator as static_cast(0x121) = 0x21 == '!' which is an operator{0} {1}# Isolate{0} {7}Ä¡{0} {1}# Continuing from operator{0} {6}({7}Ä¡{6}){0} tmpok_q575y/lexilla/test/examples/powershell/SciTE.properties0000664000175000017500000000034414773064066024252 0ustar gusnangusnanlexer.*.ps1=powershell fold=1 keywords.*.ps1=break if else in local keywords2.*.ps1=write-host write-output keywords3.*.ps1=cd chdir cat keywords4.*.ps1=mkdir prompt get-verb keywords5.*.ps1=lexilla 7z keywords6.*.ps1=synopsis tmpok_q575y/lexilla/test/examples/powershell/CharacterTruncation.ps1.folded0000664000175000017500000000061714773064066027014 0ustar gusnangusnan 0 400 400 # -*- coding: utf-8 -*- 0 400 400 # Show problem with character value truncation causing U+0121 'Ä¡' (LATIN SMALL LETTER G WITH DOT ABOVE) 0 400 400 # to be styled as an operator as static_cast(0x121) = 0x21 == '!' which is an operator 1 400 400 0 400 400 # Isolate 0 400 400 Ä¡ 1 400 400 0 400 400 # Continuing from operator 0 400 400 (Ä¡) 0 400 0 tmpok_q575y/lexilla/test/examples/powershell/Pull99Comment.ps1.styled0000664000175000017500000000005714773064066025537 0ustar gusnangusnan{1}# End comment before \r carriage return.{0} tmpok_q575y/lexilla/test/examples/powershell/NumericLiterals.ps1.folded0000664000175000017500000000162614773064066026154 0ustar gusnangusnan 0 400 400 # Treat any leading [-+] as default to reduce match complexity 0 400 400 # https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_numeric_literals?view=powershell-7.3#examples 0 400 400 100 0 400 400 100u 0 400 400 100D 0 400 400 100l 0 400 400 100uL 0 400 400 100us 0 400 400 100uy 0 400 400 100y 0 400 400 1e2 0 400 400 1.e2 0 400 400 0x1e2 0 400 400 0x1e2L 0 400 400 0x1e2D 0 400 400 482D 0 400 400 482gb 0 400 400 482ngb 0 400 400 0x1e2lgb 0 400 400 0b1011011 0 400 400 0xFFFFs 0 400 400 0xFFFFFFFF 0 400 400 -0xFFFFFFFF 0 400 400 0xFFFFFFFFu 1 400 400 0 400 400 # Float 0 400 400 0.5 0 400 400 .5 1 400 400 0 400 400 # Range 0 400 400 1..100 1 400 400 0 400 400 # Issue118: 7d is numeric while 7z is user defined keyword 0 400 400 7d 0 400 400 7z 0 400 0 tmpok_q575y/lexilla/test/examples/powershell/NumericLiterals.ps10000664000175000017500000000070214773064066024712 0ustar gusnangusnan# Treat any leading [-+] as default to reduce match complexity # https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_numeric_literals?view=powershell-7.3#examples 100 100u 100D 100l 100uL 100us 100uy 100y 1e2 1.e2 0x1e2 0x1e2L 0x1e2D 482D 482gb 482ngb 0x1e2lgb 0b1011011 0xFFFFs 0xFFFFFFFF -0xFFFFFFFF 0xFFFFFFFFu # Float 0.5 .5 # Range 1..100 # Issue118: 7d is numeric while 7z is user defined keyword 7d 7z tmpok_q575y/lexilla/test/examples/powershell/NumericLiterals.ps1.styled0000664000175000017500000000121414773064066026214 0ustar gusnangusnan{1}# Treat any leading [-+] as default to reduce match complexity{0} {1}# https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_numeric_literals?view=powershell-7.3#examples{0} {4}100{0} {4}100u{0} {4}100D{0} {4}100l{0} {4}100uL{0} {4}100us{0} {4}100uy{0} {4}100y{0} {4}1e2{0} {4}1.e2{0} {4}0x1e2{0} {4}0x1e2L{0} {4}0x1e2D{0} {4}482D{0} {4}482gb{0} {4}482ngb{0} {4}0x1e2lgb{0} {4}0b1011011{0} {4}0xFFFFs{0} {4}0xFFFFFFFF{0} {6}-{4}0xFFFFFFFF{0} {4}0xFFFFFFFFu{0} {1}# Float{0} {4}0.5{0} {4}.5{0} {1}# Range{0} {4}1{6}..{4}100{0} {1}# Issue118: 7d is numeric while 7z is user defined keyword{0} {4}7d{0} {12}7z{0} tmpok_q575y/lexilla/test/examples/powershell/AllStyles.ps1.folded0000664000175000017500000000263414773064066024766 0ustar gusnangusnan 0 400 400 # Enumerate all styles: 0 to 16 1 400 400 0 400 400 # line comment = 1 0 400 400 # more comment 1 400 400 0 400 400 # whitespace = 0 0 400 400 # spaces 1 400 400 0 400 400 # string = 2 0 400 400 "a string" 1 400 400 0 400 400 # character = 3 0 400 400 'c' 1 400 400 0 400 400 # number = 4 0 400 400 123 1 400 400 0 400 400 # variable = 5 0 400 400 $variable 1 400 400 0 400 400 # operator = 6 0 400 400 (); 1 400 400 0 400 400 # identifier = 7 0 400 400 identifier 1 400 400 0 400 400 # keyword = 8 0 400 400 break 0 400 400 ; 1 400 400 0 400 400 # cmdlet = 9 0 400 400 Write-Output "test output" 1 400 400 0 400 400 # alias = 10 0 400 400 chdir C:\Temp\ 1 400 400 0 400 400 # function = 11 0 400 400 Get-Verb -Group Security 1 400 400 0 400 400 # user-defined keyword = 12 0 400 400 lexilla 1 400 400 0 400 400 # multi-line comment = 13 0 400 400 <# 0 400 400 multi-line comment 0 400 400 #> 1 400 400 0 400 400 # here string = 14 0 400 400 @" 0 400 400 here string double 0 400 400 "@ 1 400 400 0 400 400 # here string single quote = 15 0 400 400 @' 0 400 400 here string single 0 400 400 '@ 1 400 400 0 400 400 # comment keyword = 16 0 400 400 <# 0 400 400 .synopsis 0 400 400 End of file. 0 400 400 #> 0 400 0 tmpok_q575y/lexilla/test/examples/powershell/AllStyles.ps1.styled0000664000175000017500000000156414773064066025036 0ustar gusnangusnan{1}# Enumerate all styles: 0 to 16{0} {1}# line comment = 1{0} {1}# more comment{0} {1}# whitespace = 0{0} {1}# spaces{0} {1}# string = 2{0} {2}"a string"{0} {1}# character = 3{0} {3}'c'{0} {1}# number = 4{0} {4}123{0} {1}# variable = 5{0} {5}$variable{0} {1}# operator = 6{0} {6}();{0} {1}# identifier = 7{0} {7}identifier{0} {1}# keyword = 8{0} {8}break{0} {6};{0} {1}# cmdlet = 9{0} {9}Write-Output{0} {2}"test output"{0} {1}# alias = 10{0} {10}chdir{0} {7}C{6}:{0}\{7}Temp{0}\ {1}# function = 11{0} {11}Get-Verb{0} {6}-{7}Group{0} {7}Security{0} {1}# user-defined keyword = 12{0} {12}lexilla{0} {1}# multi-line comment = 13{0} {13}<# multi-line comment #>{0} {1}# here string = 14{0} {14}@" here string double "@{0} {1}# here string single quote = 15{0} {15}@' here string single '@{0} {1}# comment keyword = 16{0} {13}<# {16}.synopsis{13} End of file. #>{0} tmpok_q575y/lexilla/test/examples/powershell/CharacterTruncation.ps10000664000175000017500000000041514773064066025554 0ustar gusnangusnan# -*- coding: utf-8 -*- # Show problem with character value truncation causing U+0121 'Ä¡' (LATIN SMALL LETTER G WITH DOT ABOVE) # to be styled as an operator as static_cast(0x121) = 0x21 == '!' which is an operator # Isolate Ä¡ # Continuing from operator (Ä¡) tmpok_q575y/lexilla/test/examples/powershell/Pull92.ps1.folded0000664000175000017500000000067314773064066024142 0ustar gusnangusnan 0 400 400 <# Tests for PowerShell #> 1 400 400 0 400 400 <# Backticks should escape in double quoted strings #> 0 400 400 $double_quote_str_esc_1 = "`"XXX`"" 0 400 400 $double_quote_str_esc_2 = "This `"string`" `$useses `r`n Backticks '``'" 1 400 400 0 400 400 <# Backticks should be ignored in quoted strings #> 0 400 400 $single_quote_str_esc_1 = 'XXX`' 0 400 400 $single_quote_str_esc_2 = 'XXX```' 0 400 0 tmpok_q575y/lexilla/test/examples/powershell/AllStyles.ps10000664000175000017500000000115114773064066023523 0ustar gusnangusnan# Enumerate all styles: 0 to 16 # line comment = 1 # more comment # whitespace = 0 # spaces # string = 2 "a string" # character = 3 'c' # number = 4 123 # variable = 5 $variable # operator = 6 (); # identifier = 7 identifier # keyword = 8 break ; # cmdlet = 9 Write-Output "test output" # alias = 10 chdir C:\Temp\ # function = 11 Get-Verb -Group Security # user-defined keyword = 12 lexilla # multi-line comment = 13 <# multi-line comment #> # here string = 14 @" here string double "@ # here string single quote = 15 @' here string single '@ # comment keyword = 16 <# .synopsis End of file. #> tmpok_q575y/lexilla/test/examples/d/0000775000175000017500000000000014773064066017223 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/d/x.d.folded0000664000175000017500000000214714773064066021077 0ustar gusnangusnan 0 400 400 $ 0 400 400 // /++ +/ doccomments are not yet supported 0 400 400 /* */ 0 400 400 /** */ 0 400 400 /// drdr 0 400 400 /+ /+ +/ +/ 0 400 400 //keyword test 0 400 400 keyword1 0 400 400 keyword2 0 400 400 keyword4 0 400 400 keyword5 0 400 400 keyword6 0 400 400 keyword7 0 400 400 //unicode identifier test 0 400 400 вапёasdÓΘΣαԷԸՑהכ拉麺ã¨ã²ã‚·ãƒžã‚¤ë‹¨ê²°ì„ 0 400 400 //strings test 0 400 400 's 0 400 400 ' 0 400 400 w's'w 0 400 400 "multiline 0 400 400 string"w 0 400 400 e"zz"e 0 400 400 r"asd\"e 0 400 400 r"multiline 0 400 400 string"c 0 400 400 r`asd\`e 0 400 400 `multiline 0 400 400 string`d 0 400 400 x"023 abc"e 0 400 400 x"023 0 400 400 abc"w 0 400 400 //numbers test 0 400 400 a[3..4]=3 0 400 400 2.stringof 0 400 400 2.0.stringof 0 400 400 2. 0 400 400 2.2e+2 0 400 400 2.2e-2 0 400 400 .2e+2 0 400 400 .2 0 400 400 2e+2 0 400 400 0x2e+2 0 400 400 0x2ep+10 0 400 400 ,.2.stringof, 1 400 400 0 400 400 end 1 400 400 0 400 0 tmpok_q575y/lexilla/test/examples/d/SciTE.properties0000664000175000017500000000025414773064066022311 0ustar gusnangusnanlexer.*.d=d keywords.*.d=keyword1 keywords2.*.d=keyword2 keywords3.*.d= keywords4.*.d=keyword4 keywords5.*.d=keyword5 keywords6.*.d=keyword6 keywords7.*.d=keyword7 fold=1 tmpok_q575y/lexilla/test/examples/d/x.d0000664000175000017500000000077214773064066017645 0ustar gusnangusnan$ // /++ +/ doccomments are not yet supported /* */ /** */ /// drdr /+ /+ +/ +/ //keyword test keyword1 keyword2 keyword4 keyword5 keyword6 keyword7 //unicode identifier test вапёasdÓΘΣαԷԸՑהכ拉麺ã¨ã²ã‚·ãƒžã‚¤ë‹¨ê²°ì„ //strings test 's ' w's'w "multiline string"w e"zz"e r"asd\"e r"multiline string"c r`asd\`e `multiline string`d x"023 abc"e x"023 abc"w //numbers test a[3..4]=3 2.stringof 2.0.stringof 2. 2.2e+2 2.2e-2 .2e+2 .2 2e+2 0x2e+2 0x2ep+10 ,.2.stringof, end tmpok_q575y/lexilla/test/examples/d/x.d.styled0000664000175000017500000000147014773064066021144 0ustar gusnangusnan{14}${0} {2}// /++ +/ doccomments are not yet supported {1}/* */{0} {3}/** */{0} {15}/// drdr {4}/+ /+ +/ +/{0} {2}//keyword test {6}keyword1{0} {7}keyword2{0} {9}keyword4{0} {20}keyword5{0} {21}keyword6{0} {22}keyword7{0} {2}//unicode identifier test {14}вапёasdÓΘΣαԷԸՑהכ拉麺ã¨ã²ã‚·ãƒžã‚¤ë‹¨ê²°ì„{0} {2}//strings test {11}'s ' {14}w{12}'s'{14}w{0} {10}"multiline string"w{0} {14}e{10}"zz"{14}e{0} {19}r"asd\"{14}e{0} {19}r"multiline string"c{0} {14}r{18}`asd\`{14}e{0} {18}`multiline string`d{0} {19}x"023 abc"{14}e{0} {19}x"023 abc"w{0} {2}//numbers test {14}a{13}[{5}3{13}..{5}4{13}]={5}3{0} {5}2.stringof{0} {5}2.0{13}.{14}stringof{0} {5}2.{0} {5}2.2e+2{0} {5}2.2e-2{0} {5}.2e+2{0} {5}.2{0} {5}2e+2{0} {5}0x2e{13}+{5}2{0} {5}0x2ep+10{0} {13},{5}.2{13}.{14}stringof{13},{0} {14}end{0} tmpok_q575y/lexilla/test/examples/bash/0000775000175000017500000000000014773064066017715 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/bash/Issue180.bsh.folded0000664000175000017500000000026714773064066023175 0ustar gusnangusnan 0 400 0 echo '$' 0 400 0 echo "$" 0 400 0 echo "$" 0 400 0 echo "$"x"" 0 400 0 echo x$'\t'y 0 400 0 echo "x$'\t'y" 0 400 0 echo "x\ty" 0 400 0 tmpok_q575y/lexilla/test/examples/bash/Issue180.bsh0000664000175000017500000000011714773064066021733 0ustar gusnangusnanecho '$' echo "$" echo "$" echo "$"x"" echo x$'\t'y echo "x$'\t'y" echo "x\ty" tmpok_q575y/lexilla/test/examples/bash/202LineStartOption.bsh.styled0000664000175000017500000000212414773064066025237 0ustar gusnangusnan{8}-a{0} {2}#{0} {8}-b{0} {2}#{0} {8}declare{0} {8}-A{0} {8}optionSet{7}=([{8}--help{7}]={3}0{7}){0} {4}for{0} {8}option{0} {4}in{0} {7}{{8}-h{7},{8}--help{7},{8}--version{7},{8}--verbose{7},{8}-{7},{8}--{7}};{0} {4}do{0} {4}case{0} {9}$option{0} {4}in{0} {8}-h{7}|{8}--help{7}){0} {8}optionSet{7}[{8}--help{7}]={3}1{0} {4}echo{0} {8}help{7}:{0} {9}$option{0} {7};;{0} {8}-{7}*{8}-version{7}){0} {4}echo{0} {8}version{7}:{0} {9}$option{0} {7};;{0} {8}--{7}){0} {4}echo{0} {8}stop{0} {7};;{0} {8}-{7}){0} {4}echo{0} {8}stdin{0} {7};;{0} {8}-{7}*[{8}-a-zA-Z0-9{7}]){0} {4}echo{0} {8}other{7}:{0} {9}$option{0} {7};;{0} {4}esac{0} {4}done{0} {8}option{7}={8}--help{0} {7}[[{0} {9}$option{0} {7}=={0} {7}*{8}-h{7}*{0} {7}]]{0} {7}&&{0} {4}echo{0} {9}$option{7}={10}${optionSet[$option]}{0} {4}for{0} {8}gcc{0} {4}in{0} {8}gcc{7}{,-{3}1{7}{{3}4{7}..{3}0{7}..-{3}1{7}}};{0} {4}do{0} {4}echo{0} {9}$gcc{0} {4}done{0} {4}for{0} {8}gcc{0} {4}in{0} {8}gcc{7}{,{-{3}14{7}..-{3}10{7}}};{0} {4}do{0} {4}echo{0} {9}$gcc{0} {4}done{0} {2}# Tilde-refix ~{0} {7}~+/{8}foo{0} {7}~-/{8}foo{0} tmpok_q575y/lexilla/test/examples/bash/197ArithmeticOperator.bsh.styled0000664000175000017500000000155714773064066025774 0ustar gusnangusnan{8}hello{7}={5}"hello, "{0} {8}hello{7}+={8}word{0} {4}echo{0} {9}$hello{0} {4}for{0} {7}(({8}i{0} {7}={0} {3}2{7};{0} {8}i{0} {7}>{0} {3}0{7};{0} {8}i{7}--));{0} {4}do{0} {4}echo{0} {8}postfix{0} {8}dec{0} {9}$i{0} {4}done{0} {4}for{0} {7}(({8}i{0} {7}={0} {3}2{7};{0} {8}i{0} {7}>{0} {3}0{7};{0} {7}--{8}i{7}));{0} {4}do{0} {4}echo{0} {8}prefix{0} {8}dec{0} {9}$i{0} {4}done{0} {4}for{0} {7}(({8}i{0} {7}={0} {3}0{7};{0} {8}i{0} {7}<{0} {3}2{7};{0} {8}i{7}++));{0} {4}do{0} {4}echo{0} {8}postfix{0} {8}inc{0} {9}$i{0} {4}done{0} {4}for{0} {7}(({8}i{0} {7}={0} {3}0{7};{0} {8}i{0} {7}<{0} {3}2{7};{0} {7}++{8}i{7}));{0} {4}do{0} {4}echo{0} {8}prefix{0} {8}inc{0} {9}$i{0} {4}done{0} {2}# issue 215{0} {4}for{0} {7}(({8}i{0} {7}={0} {3}0{7};{0} {8}i{0} {7}<{0} {3}2{7};{0} {8}i{7}++));{0} {4}do{0} {4}echo{0} {7}$(((({3}1{7})){0} {7}<<{0} {8}i{7})){0} {4}done{0} tmpok_q575y/lexilla/test/examples/bash/257Delimiter.bsh.folded0000664000175000017500000000272114773064066024025 0ustar gusnangusnan 2 400 0 + cat < $OUT_FILE 1 400 0 0 400 0 # Issue 188, keyword before redirection operator 0 400 0 pwd>>$OUT_FILE 1 400 0 0 400 0 find "$PROJECT_PATH/src" -maxdepth 1 -type f |\ 2 400 0 + while read -r f; do 2 401 0 + { 0 402 0 | python3 -c "print();print('='*50)";\ 0 402 0 | echo `basename "$f"` | tr -d 'x';\ 0 402 0 | python3 -c "print('='*50)";\ 0 402 0 | python3 "$f";\ 0 402 0 | } >> $OUT_FILE 0 401 0 | done 1 400 0 0 400 0 # Issue 137, should be shift but here-doc was detected 0 400 0 echo $(( x << END )) 0 400 0 pwd 0 400 0 END 1 400 0 0 400 0 # Issue 194, failed to understand character escaping so string unterminated 0 400 0 echo "foo `echo foo \\" bar` bar" 0 400 0 echo "xinput set-prop bla \"blub\" `grep bla $WRITE_APPENDIX/var/lib/path.txt | cut -d \\" -f 4`" >/some_file.sh 1 400 0 0 400 0 # Issue 194, $ before end of backticks is literal 0 400 0 echo `echo \$` 0 400 0 echo `echo \$bar\$` 0 400 0 echo `echo $` 0 400 0 echo `echo $bar$` 1 400 0 0 400 0 INVALID_NUMBER=0#0000 0 400 0 tmpok_q575y/lexilla/test/examples/bash/NestedRich.bsh.folded0000664000175000017500000000150414773064066023677 0ustar gusnangusnan 2 400 0 + # Use lexer.bash.command.substitution=2 to style command substitution 0 401 0 | # so that both the scope of the command and the internal structure are visible. 1 400 0 0 400 0 # Nested command 0 400 0 $(ls -la$(ls *.c)) 1 400 0 0 400 0 # Check strings and backticks in command 0 400 0 echo $('ls' "." `ls` $'.' $".") 1 400 0 0 400 0 PROJECT_DIR=$(rlwrap -S "Enter source path: " -e '' -i -o cat) 1 400 0 0 400 0 # Multiple nesting levels 0 400 0 $(ls -la$(ls $(c) $'*.c' ` $(${s})`)) 1 400 0 0 400 0 # Multi-line 0 400 0 $(ls | 0 400 0 more) 1 400 0 0 400 0 $( 0 400 0 `x` 0 400 0 "x" 0 400 0 `ls` 0 400 0 $'x' 0 400 0 $"x" 0 400 0 ) 0 400 0 #end -- checks termination of previous 0 400 0 tmpok_q575y/lexilla/test/examples/bash/NestedRich.bsh0000664000175000017500000000074514773064066022451 0ustar gusnangusnan# Use lexer.bash.command.substitution=2 to style command substitution # so that both the scope of the command and the internal structure are visible. # Nested command $(ls -la$(ls *.c)) # Check strings and backticks in command echo $('ls' "." `ls` $'.' $".") PROJECT_DIR=$(rlwrap -S "Enter source path: " -e '' -i -o cat) # Multiple nesting levels $(ls -la$(ls $(c) $'*.c' ` $(${s})`)) # Multi-line $(ls | more) $( `x` "x" `ls` $'x' $"x" ) #end -- checks termination of previous tmpok_q575y/lexilla/test/examples/bash/continuation.bsh0000664000175000017500000000026114773064066023124 0ustar gusnangusnan# Tests for line continuation. # Issue #195. #backslash1\ echo 1 #backslash2\\ echo 2 if [ 1 ]; then backslash1=A\ fi backslash2=B\\ fi echo $backslash1, $backslash2 tmpok_q575y/lexilla/test/examples/bash/SciTE.properties0000664000175000017500000000211014773064066022774 0ustar gusnangusnanlexer.*.bsh;*.zsh=bash fold=1 fold.comment=1 keywords.*.bsh;*.zsh=case cat do done echo else esac exit export fi find for if in print pwd set setopt then while # Can use substyles for identifiers and scalars substyles.bash.8=1 substylewords.8.1.*.bsh=map substyles.bash.9=1 substylewords.9.1.*.bsh=CWD lexer.bash.styling.inside.string=0 lexer.bash.styling.inside.backticks=0 lexer.bash.styling.inside.parameter=0 lexer.bash.styling.inside.heredoc=0 lexer.bash.command.substitution=0 match Issue180.bsh lexer.bash.styling.inside.string=1 match Issue182.bsh lexer.bash.styling.inside.string=1 match Issue184.bsh lexer.bash.styling.inside.string=1 lexer.bash.command.substitution=1 match Issue184Copy.bsh lexer.bash.styling.inside.string=1 lexer.bash.command.substitution=1 lexer.bash.special.parameter=*@#?-$!%< match NestedStyledInside.bsh lexer.bash.styling.inside.string=1 lexer.bash.styling.inside.backticks=1 lexer.bash.styling.inside.parameter=1 lexer.bash.styling.inside.heredoc=1 lexer.bash.command.substitution=1 match NestedRich.bsh lexer.bash.command.substitution=2 tmpok_q575y/lexilla/test/examples/bash/continuation.bsh.styled0000664000175000017500000000047314773064066024434 0ustar gusnangusnan{2}# Tests for line continuation.{0} {2}# Issue #195.{0} {2}#backslash1\{0} {4}echo{0} {3}1{0} {2}#backslash2\\{0} {4}echo{0} {3}2{0} {4}if{0} {7}[{0} {3}1{0} {7}];{0} {4}then{0} {8}backslash1{7}={8}A{7}\{0} {8}fi{0} {8}backslash2{7}={8}B\\{0} {4}fi{0} {4}echo{0} {9}$backslash1{7},{0} {9}$backslash2{0} tmpok_q575y/lexilla/test/examples/bash/203TestOption.bsh.styled0000664000175000017500000000163714773064066024262 0ustar gusnangusnan{7}[[{0} {9}$1{0} {7}=={0} {8}-e{7}*{0} {7}]]{0} {7}&&{0} {4}echo{0} {8}e{0} {4}if{0} {7}[[{0} {4}-d{0} {7}/{8}usr{7}/{8}bin{0} {7}&&{0} {4}-e{0} {7}/{8}usr{7}/{8}bin{7}/{8}bash{0} {7}]];{0} {4}then{0} {4}echo{0} {8}find{0} {8}bash{0} {4}fi{0} {4}if{0} {7}[[{0} {4}-d{0} {7}/{8}usr{7}/{8}bin{0} {7}&&{0} {4}-e{0} {7}/{8}usr{7}/{8}bin{7}/{8}bash{0} {7}]];{0} {4}then{0} {4}echo{0} {8}find{0} {8}bash{0} {4}fi{0} {4}if{0} {7}[{0} {4}-d{0} {7}/{8}usr{7}/{8}bin{0} {7}&&{0} {8}-e{0} {7}/{8}usr{7}/{8}bin{7}/{8}bash{0} {7}];{0} {4}then{0} {4}echo{0} {8}find{0} {8}bash{0} {4}fi{0} {4}if{0} {7}[{0} {4}-d{0} {7}/{8}usr{7}/{8}bin{0} {7}&&{0} {8}-e{0} {7}/{8}usr{7}/{8}bin{7}/{8}bash{0} {7}];{0} {4}then{0} {4}echo{0} {8}find{0} {8}bash{0} {4}fi{0} {4}if{0} {7}[{0} {4}-d{0} {7}/{8}usr{7}/{8}bin{0} {7}&&{0} {7}\{0} {8}-e{0} {7}/{8}usr{7}/{8}bin{7}/{8}bash{0} {7}];{0} {4}then{0} {4}echo{0} {8}find{0} {8}bash{0} {4}fi{0} tmpok_q575y/lexilla/test/examples/bash/Nested.bsh.folded0000664000175000017500000000420514773064066023072 0ustar gusnangusnan 0 400 0 # Nested elements and other complex cases 1 400 0 0 400 0 # String with backtick inclusion 0 400 0 "x`ls`" 0 400 0 # Nested string 0 400 0 "x`ls "*.c"`" 0 400 0 # Not terminated at first " 0 400 0 "x`ls" # "`" # 1 400 0 0 400 0 # String with command inclusion 0 400 0 "x$(ls)" 1 400 0 0 400 0 # Nested command 0 400 0 $(ls -la$(ls *.c)) 1 400 0 0 400 0 # Check strings and backticks in command 0 400 0 echo $('ls' "." `ls` $'.' $".") 1 400 0 0 400 0 # $( not terminated by ) if contains unterminated string 0 400 0 $('x) # ') # 0 400 0 $("x) # ") # 0 400 0 $(`x) # `) # Bash doesn't like this 0 400 0 $($'x) # ') # 0 400 0 $($"x) # ") # 1 400 0 0 400 0 # Parameter expansion 0 400 0 var=abcdef 0 400 0 sub=abc 0 400 0 rep='& ' 0 400 0 echo ${var/$sub/"${rep}}"} # 0 400 0 # issue 216 0 400 0 option="no[foo]" 0 400 0 option=${option%%[<{().[]*} 0 400 0 echo $option 1 400 0 0 400 0 # '$' in variable 0 400 0 echo $$PID 0 400 0 echo $var${var} 1 400 0 0 400 0 # Here-doc with internal elements 2 400 0 + cat < $OUT_FILE # Issue 188, keyword before redirection operator pwd>>$OUT_FILE find "$PROJECT_PATH/src" -maxdepth 1 -type f |\ while read -r f; do { python3 -c "print();print('='*50)";\ echo `basename "$f"` | tr -d 'x';\ python3 -c "print('='*50)";\ python3 "$f";\ } >> $OUT_FILE done # Issue 137, should be shift but here-doc was detected echo $(( x << END )) pwd END # Issue 194, failed to understand character escaping so string unterminated echo "foo `echo foo \\" bar` bar" echo "xinput set-prop bla \"blub\" `grep bla $WRITE_APPENDIX/var/lib/path.txt | cut -d \\" -f 4`" >/some_file.sh # Issue 194, $ before end of backticks is literal echo `echo \$` echo `echo \$bar\$` echo `echo $` echo `echo $bar$` INVALID_NUMBER=0#0000 tmpok_q575y/lexilla/test/examples/bash/257Delimiter.bsh0000664000175000017500000000101714773064066022566 0ustar gusnangusnancat < 0; i--)); do echo postfix dec $i done for ((i = 2; i > 0; --i)); do echo prefix dec $i done for ((i = 0; i < 2; i++)); do echo postfix inc $i done for ((i = 0; i < 2; ++i)); do echo prefix inc $i done # issue 215 for ((i = 0; i < 2; i++)); do echo $((((1)) << i)) done tmpok_q575y/lexilla/test/examples/bash/Issue180.bsh.styled0000664000175000017500000000025714773064066023243 0ustar gusnangusnan{4}echo{0} {6}'$'{0} {4}echo{0} {5}"$"{0} {4}echo{0} {5}"$"{0} {4}echo{0} {5}"$"{8}x{5}""{0} {4}echo{0} {8}x{5}$'\t'{8}y{0} {4}echo{0} {5}"x$'\t'y"{0} {4}echo{0} {5}"x\ty"{0} tmpok_q575y/lexilla/test/examples/bash/NestedStyledInside.bsh.folded0000664000175000017500000000401314773064066025410 0ustar gusnangusnan 0 400 0 # Nested elements and other complex cases 1 400 0 0 400 0 # String with backtick inclusion 0 400 0 "x`ls`" 0 400 0 # Nested string 0 400 0 "x`ls "*.c"`" 0 400 0 # Not terminated at first " 0 400 0 "x`ls" # "`" # 1 400 0 0 400 0 # String with command inclusion 0 400 0 "x$(ls)" 1 400 0 0 400 0 # Nested command 0 400 0 $(ls -la$(ls *.c)) 1 400 0 0 400 0 # Check strings and backticks in command 0 400 0 echo $('ls' "." `ls` $'.' $".") 1 400 0 0 400 0 # $( not terminated by ) if contains unterminated string 0 400 0 $('x) # ') # 0 400 0 $("x) # ") # 0 400 0 $(`x) # `) # Bash doesn't like this 0 400 0 $($'x) # ') # 0 400 0 $($"x) # ") # 1 400 0 0 400 0 # Parameter expansion 0 400 0 var=abcdef 0 400 0 sub=abc 0 400 0 rep='& ' 0 400 0 echo ${var/$sub/"${rep}}"} # 1 400 0 0 400 0 # '$' in variable 0 400 0 echo $$PID 0 400 0 echo $var${var} 1 400 0 0 400 0 # Here-doc with internal elements 2 400 0 + cat <{0} {9}$OUT_FILE{0} {2}# Issue 188, keyword before redirection operator{0} {4}pwd{7}>>{9}$OUT_FILE{0} {4}find{0} {5}"$PROJECT_PATH/src"{0} {8}-maxdepth{0} {3}1{0} {8}-type{0} {8}f{0} {7}|\{0} {4}while{0} {8}read{0} {8}-r{0} {8}f{7};{0} {4}do{0} {7}{{0} {8}python3{0} {8}-c{0} {5}"print();print('='*50)"{7};\{0} {4}echo{0} {11}`basename "$f"`{0} {7}|{0} {8}tr{0} {8}-d{0} {6}'x'{7};\{0} {8}python3{0} {8}-c{0} {5}"print('='*50)"{7};\{0} {8}python3{0} {5}"$f"{7};\{0} {7}}{0} {7}>>{0} {9}$OUT_FILE{0} {4}done{0} {2}# Issue 137, should be shift but here-doc was detected{0} {4}echo{0} {7}$(({0} {8}x{0} {7}<<{0} {8}END{0} {7})){0} {4}pwd{0} {8}END{0} {2}# Issue 194, failed to understand character escaping so string unterminated{0} {4}echo{0} {5}"foo `echo foo \\" bar` bar"{0} {4}echo{0} {5}"xinput set-prop bla \"blub\" `grep bla $WRITE_APPENDIX/var/lib/path.txt | cut -d \\" -f 4`"{0} {7}>/{8}some_file.sh{0} {2}# Issue 194, $ before end of backticks is literal{0} {4}echo{0} {11}`echo \$`{0} {4}echo{0} {11}`echo \$bar\$`{0} {4}echo{0} {11}`echo $`{0} {4}echo{0} {11}`echo $bar$`{0} {8}INVALID_NUMBER{7}={1}0#0000{0} tmpok_q575y/lexilla/test/examples/bash/199Numbers.bsh.folded0000664000175000017500000000735214773064066023534 0ustar gusnangusnan 0 400 0 # Lexing numeric literals 1 400 0 0 400 0 # From issue #199 1 400 0 0 400 0 # UUIDs 1 400 0 0 400 0 virsh start 61a6a312-86d3-458c-824a-fa0adc2bd22c 0 400 0 virsh start 61969312-86d3-458c-8249-fa0adc2bd22c 0 400 0 virsh restore /opt/61a6a312-86d3-458c-824a-fa0adc2bd22c-suspend 1 400 0 0 400 0 # Git items 1 400 0 0 400 0 git checkout 998d611b516b0e485803089ecd53fdf0ea707a8c 1 400 0 0 400 0 git log --no-walk 0e2ba9c 0 400 0 git log --no-walk rel-5-2-4-97-g7405d4e7 1 400 0 0 400 0 # Arithmetic and character ranges 1 400 0 0 400 0 declare -i a=1+1; echo $a 0 400 0 [[ $a == [0-9] ]] && echo 1 1 400 0 0 400 0 # Brace expansion 1 400 0 2 400 0 + for i in {1..10..2}; do 0 401 0 | echo $i 0 401 0 | done 2 400 0 + for a in {A..Z..2}; do 0 401 0 | echo $a 0 401 0 | done 1 400 0 0 400 0 # From Kein-Hong Man 1 400 0 2 400 0 + #-------------------------------------------------------------------------- 0 401 0 | # Bash number formats 0 401 0 | # (20070712) 0 401 0 | # Octal lexing relaxed to allow hex digits to avoid flagging unnecessary 0 401 0 | # and misleading number errors; radix-prefixed lexing behaviour is unchanged, 0 401 0 | # as those cases are uncommon (to get strict lexing, define PEDANTIC_OCTAL). 1 400 0 2 400 0 + # NOTE: Some people may want an entire non-number to be lexed in the normal 0 401 0 | # style and not as part-number part-normal. If the user thinks there is a 0 401 0 | # better case for the former, please lobby for it on the SF issue tracker. 1 400 0 0 400 0 0123 0567 # octal good 0 400 0 08 0789 077ABC # octal bad (disabled 20070712, now lexed as numbers) 0 400 0 066XYZ # octal bad 0 400 0 0xDEAD 0X1234 # hex good 0 400 0 0xABCMNO 0XGHI # hex bad 1 400 0 2 400 0 + # extended "[base#]n" format where base is between 2-64 0 401 0 | # digits range are 0-9a-zA-Z@_ 0 401 0 | # if base <= 36, then alphabets are case insensitive 0 401 0 | # this style isn't likely in non-number code, so the lexer currently 0 401 0 | # opts to colour the error in red -- send feedback if this is too 0 401 0 | # intrusive; 'invalid octals' (but valid text) in red proved annoying... 1 400 0 0 400 0 2#10101 # binary 0 400 0 2#23456 # error (in red) 0 400 0 8#0123456789AB # error (in red) 0 400 0 16#abcDEF123 0 400 0 16#abcpqr # bad 0 400 0 64#xyzXYZ@_789 # full base-64 0 400 0 99#xyzXYZ@_789 # error (in red; invalid base) 0 400 0 111#xyzXYZ@_789 # error (in red; invalid base) 1 400 0 0 400 0 567+0123*0xBCD # with operators 0 400 0 (4#0123-3#012) 1 400 0 2 400 0 + # 20070712: 0 401 0 | # Octal lexing relaxed to avoid marking some number sequences as octal 0 401 0 | # errors. This is because the elements or apps controlled by bash may 0 401 0 | # have a different view of numbers, so we avoid flagging unnecessary 0 401 0 | # (and misleading) number errors. Radix-prefixed number lexing is 0 401 0 | # unchanged, as those cases are uncommon (no feedback on it yet.) 1 400 0 2 400 0 + # In the following, red-flagged 'octals' should now be lexed as normal 0 401 0 | # numbers, allowing hex digits. 1 400 0 0 400 0 # flightgear missing.sh 0 400 0 scriptversion=2004-09-07.08 1 400 0 0 400 0 # git t/t0000/basic.sh 0 400 0 P=087704a96baf1c2d1c869a8b084481e121c88b5b 1 400 0 0 400 0 # openssh config.guess 0 400 0 *:procnto*:*:* | *:QNX:[0123456789]*:*) 1 400 0 0 400 0 # with hex digits, the following will still be an invalid number 0 400 0 066XYZ 0 400 0 tmpok_q575y/lexilla/test/examples/bash/197ArithmeticOperator.bsh.folded0000664000175000017500000000116414773064066025717 0ustar gusnangusnan 0 400 0 hello="hello, " 0 400 0 hello+=word 0 400 0 echo $hello 1 400 0 2 400 0 + for ((i = 2; i > 0; i--)); do 0 401 0 | echo postfix dec $i 0 401 0 | done 2 400 0 + for ((i = 2; i > 0; --i)); do 0 401 0 | echo prefix dec $i 0 401 0 | done 2 400 0 + for ((i = 0; i < 2; i++)); do 0 401 0 | echo postfix inc $i 0 401 0 | done 2 400 0 + for ((i = 0; i < 2; ++i)); do 0 401 0 | echo prefix inc $i 0 401 0 | done 1 400 0 0 400 0 # issue 215 2 400 0 + for ((i = 0; i < 2; i++)); do 0 401 0 | echo $((((1)) << i)) 0 401 0 | done 0 400 0 tmpok_q575y/lexilla/test/examples/bash/continuation.bsh.folded0000664000175000017500000000060114773064066024356 0ustar gusnangusnan 2 400 0 + # Tests for line continuation. 0 401 0 | # Issue #195. 1 400 0 0 400 0 #backslash1\ 0 400 0 echo 1 0 400 0 #backslash2\\ 0 400 0 echo 2 1 400 0 2 400 0 + if [ 1 ]; then 0 401 0 | backslash1=A\ 0 401 0 | fi 0 401 0 | backslash2=B\\ 0 401 0 | fi 1 400 0 0 400 0 echo $backslash1, $backslash2 0 400 0 tmpok_q575y/lexilla/test/examples/bash/Issue184.bsh0000664000175000017500000000020414773064066021734 0ustar gusnangusnanecho $* echo $@ echo $? echo $- echo $$ echo $! echo $_ echo $% echo $< ifeth=$(ls /sys/class/net | grep ^"$intf" | grep "$intf"$) tmpok_q575y/lexilla/test/examples/bash/AllStyles.bsh.styled0000664000175000017500000000151514773064066023634 0ustar gusnangusnan{2}# Enumerate all styles: 0 to 13{0} {2}# comment=2{0} {2}# whitespace=0{0} {2}# w{0} {2}# error=1{0} {1}0#0000{0} {2}# number=3{0} {3}123{0} {2}# keyword=4{0} {4}set{0} {2}# double-quoted-string=5{0} {5}"string"{0} {2}# single-quoted-string=6{0} {6}'str'{0} {2}# operator=7{0} {7}+{0} {2}# identifier=8{0} {8}identifier{0} {2}# scalar=9{0} {9}$scalar{0} {9}$?{8}Status{0} {2}# parameter-expansion=10{0} {10}${parameter}{0} {2}# back-ticks=11{0} {11}`ls`{0} {2}# here-doc-delimiter=12, here-doc=13{0} {12}<~ // SCE_V_IDENTIFIER {11} q x$z \my_var \/x1/n1 \\x1\n1 \{a,b} \V(p,n) // SCE_V_STRINGEOL {12} "\n // SCE_V_USER {19} my_var // SCE_V_COMMENT_WORD {20} // TODO write a comment module mod(clk, q, reset) // folded when fold.verilog.flags=1 // SCE_V_INPUT {21} input clk; // SCE_V_OUTPUT {22} output q; // SCE_V_INOUT {23} inout reset; endmodule // SCE_V_PORT_CONNECT {24} mod m1( .clk(clk), .q(q), .reset(reset) ); tmpok_q575y/lexilla/test/examples/verilog/AllStyles.vh.folded0000664000175000017500000000464714773064066024171 0ustar gusnangusnan 0 400 400 // Examples drawn from https://verilogams.com/refman/basics/index.html 0 400 400 0 400 400 // SCE_V_DEFAULT {0} 0 400 400 2 400 401 + /* 0 401 401 | * SCE_V_COMMENT {1} 0 401 400 | */ 0 400 400 2 400 401 + // SCE_V_COMMENTLINE {2} 0 401 401 | // multiple 0 401 401 | // comment lines 0 401 400 | // are folded 0 400 400 2 400 402 + //{ explicit folds 0 402 402 | // are folded, 0 402 400 | //} too 0 400 400 2 400 401 + //! SCE_V_COMMENTLINEBANG {3} 0 401 401 | //! multiple 0 401 401 | //! bang comments 0 401 400 | //! are folded 0 400 400 0 400 400 // SCE_V_NUMBER {4} 0 400 400 1'b0 0 400 400 8'hx 0 400 400 8'hfffx 0 400 400 12'hfx 0 400 400 64'o0 0 400 400 0x7f 0 400 400 0o23 0 400 400 0b1011 0 400 400 42_839 0 400 400 0.1 0 400 400 1.3u 0 400 400 5.46K 0 400 400 1.2E12 0 400 400 1.30e-2 0 400 400 236.123_763e-12 0 400 400 0 400 400 // SCE_V_WORD {5} 0 400 400 always 0 400 400 0 400 400 // SCE_V_STRING {6} 0 400 400 "\tsome\ttext\r\n" 0 400 400 0 400 400 // SCE_V_WORD2 {7} 0 400 400 special 0 400 400 0 400 400 // SCE_V_WORD3 {8} 0 400 400 $async$and$array 0 400 400 0 400 400 // SCE_V_PREPROCESSOR {9} 0 400 400 `define __VAMS_ENABLE__ 2 400 401 + `ifdef __VAMS_ENABLE__ 0 401 401 | parameter integer del = 1 from [1:100]; 2 400 401 + `else 0 401 401 | parameter del = 1; 0 401 400 | `endif 0 400 400 0 400 400 // SCE_V_OPERATOR {10} 0 400 400 +-/=!@#%^&*()[]{}<|>~ 0 400 400 0 400 400 // SCE_V_IDENTIFIER {11} 0 400 400 q 0 400 400 x$z 0 400 400 \my_var 0 400 400 \/x1/n1 0 400 400 \\x1\n1 0 400 400 \{a,b} 0 400 400 \V(p,n) 0 400 400 0 400 400 // SCE_V_STRINGEOL {12} 0 400 400 "\n 0 400 400 0 400 400 // SCE_V_USER {19} 0 400 400 my_var 0 400 400 2 400 401 + // SCE_V_COMMENT_WORD {20} 0 401 400 | // TODO write a comment 0 400 400 2 400 401 + module mod(clk, q, reset) // folded when fold.verilog.flags=1 0 401 401 | // SCE_V_INPUT {21} 0 401 401 | input clk; 0 401 401 | 0 401 401 | // SCE_V_OUTPUT {22} 0 401 401 | output q; 0 401 401 | 0 401 401 | // SCE_V_INOUT {23} 0 401 401 | inout reset; 0 401 400 | endmodule 0 400 400 0 400 400 // SCE_V_PORT_CONNECT {24} 2 400 401 + mod m1( 0 401 401 | .clk(clk), 0 401 401 | .q(q), 0 401 401 | .reset(reset) 0 401 400 | ); 0 400 0 tmpok_q575y/lexilla/test/examples/verilog/AllStyles.vh.styled0000664000175000017500000000344714773064066024235 0ustar gusnangusnan{2}// Examples drawn from https://verilogams.com/refman/basics/index.html {0} {2}// SCE_V_DEFAULT {0} {0} {1}/* * SCE_V_COMMENT {1} */{0} {2}// SCE_V_COMMENTLINE {2} // multiple // comment lines // are folded {0} {2}//{ explicit folds // are folded, //} too {0} {3}//! SCE_V_COMMENTLINEBANG {3} //! multiple //! bang comments //! are folded {0} {2}// SCE_V_NUMBER {4} {4}1'b0{0} {4}8'hx{0} {4}8'hfffx{0} {4}12'hfx{0} {4}64'o0{0} {4}0x7f{0} {4}0o23{0} {4}0b1011{0} {4}42_839{0} {4}0.1{0} {4}1.3u{0} {4}5.46K{0} {4}1.2E12{0} {4}1.30e{10}-{4}2{0} {4}236.123_763e{10}-{4}12{0} {2}// SCE_V_WORD {5} {5}always{0} {2}// SCE_V_STRING {6} {6}"\tsome\ttext\r\n"{0} {2}// SCE_V_WORD2 {7} {7}special{0} {2}// SCE_V_WORD3 {8} {8}$async$and$array{0} {2}// SCE_V_PREPROCESSOR {9} {9}`define{0} {11}__VAMS_ENABLE__{0} {9}`ifdef{0} {11}__VAMS_ENABLE__{0} {5}parameter{0} {5}integer{0} {11}del{0} {10}={0} {4}1{0} {11}from{0} {10}[{4}1{10}:{4}100{10}];{0} {9}`else{64} {69}parameter{64} {75}del{64} {74}={64} {68}1{74};{64} {9}`endif{0} {2}// SCE_V_OPERATOR {10} {10}+-/=!@#%^&*()[]{}<|>~{0} {2}// SCE_V_IDENTIFIER {11} {11}q{0} {11}x$z{0} {11}\my_var{0} {11}\/x1/n1{0} {11}\\x1\n1{0} {11}\{a,b}{0} {11}\V(p,n){0} {2}// SCE_V_STRINGEOL {12} {12}"\n {0} {2}// SCE_V_USER {19} {19}my_var{0} {2}// SCE_V_COMMENT_WORD {20} // {20}TODO{2} write a comment {0} {5}module{0} {11}mod{10}({11}clk{10},{0} {11}q{10},{0} {11}reset{10}){0} {2}// folded when fold.verilog.flags=1 // SCE_V_INPUT {21} {0} {21}input{0} {21}clk{10};{0} {2}// SCE_V_OUTPUT {22} {0} {22}output{0} {22}q{10};{0} {2}// SCE_V_INOUT {23} {0} {23}inout{0} {23}reset{10};{0} {5}endmodule{0} {2}// SCE_V_PORT_CONNECT {24} {11}mod{0} {11}m1{10}({0} {10}.{24}clk{10}({11}clk{10}),{0} {10}.{24}q{10}({11}q{10}),{0} {10}.{24}reset{10}({11}reset{10}){0} {10});{0} tmpok_q575y/lexilla/test/examples/rust/0000775000175000017500000000000014773064066017775 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/rust/Issue239.rs.styled0000664000175000017500000000023114773064066023170 0ustar gusnangusnan{6}fn{0} {17}main{16}(){0} {16}{{0} {6}let{0} {17}r#true{0} {16}={0} {6}false{16};{0} {19}println!{16}({13}"{}"{16},{0} {17}r#true{16});{0} {16}}tmpok_q575y/lexilla/test/examples/rust/Issue35.rs0000664000175000017500000000004414773064066021601 0ustar gusnangusnan/// GitHub Issue #35 fn main() {} /*tmpok_q575y/lexilla/test/examples/rust/Issue33.rs0000664000175000017500000000017114773064066021600 0ustar gusnangusnanfn main() { let a: i128 = 42i128; let b: u128 = 1337u128; println!("{} + {} = {}", a, b, (a as u128) + b); } tmpok_q575y/lexilla/test/examples/rust/Issue35.rs.folded0000664000175000017500000000011314773064066023032 0ustar gusnangusnan 0 400 400 /// GitHub Issue #35 0 400 400 fn main() {} 2 400 401 + /*tmpok_q575y/lexilla/test/examples/rust/Issue35.rs.styled0000664000175000017500000000010514773064066023102 0ustar gusnangusnan{4}/// GitHub Issue #35{0} {6}fn{0} {17}main{16}(){0} {16}{}{0} {1}/*tmpok_q575y/lexilla/test/examples/rust/Issue239.rs0000664000175000017500000000010114773064066021661 0ustar gusnangusnanfn main() { let r#true = false; println!("{}", r#true); }tmpok_q575y/lexilla/test/examples/rust/Issue34.rs0000664000175000017500000000025114773064066021600 0ustar gusnangusnan/** * SCE_RUST_COMMENTBLOCKDOC */ fn main() { /// SCE_RUST_COMMENTLINEDOC println!("Hello, World!"); } // SCE_RUST_COMMENTLINE /* * SCE_RUST_COMMENTBLOCK */ tmpok_q575y/lexilla/test/examples/rust/Issue268.rs.styled0000664000175000017500000000236314773064066023202 0ustar gusnangusnan{2}// coding: utf-8{0} {21}b"foo"{16};{0} {22}br"foo"{0} {2}// foo{0} {21}b"\"foo\""{16};{0} {22}br#""foo""#{16};{0} {2}// "foo"{0} {21}b"foo #\"# bar"{16};{0} {22}br##"foo #"# bar"##{16};{0} {2}// foo #"# bar{0} {21}b"\x52"{16};{0} {21}b"R"{16};{0} {22}br"R"{0} {2}// R{0} {21}b"\\x52"{16};{0} {22}br"\x52"{0} {2}// \x52{0} {24}c"æ"{0} {2}// LATIN SMALL LETTER AE (U+00E6){0} {24}c"\u{00E6}"{16};{0} {24}c"\xC3\xA6"{16};{0} {24}c"foo"{16};{0} {25}cr"foo"{0} {2}// foo{0} {24}c"\"foo\""{16};{0} {25}cr#""foo""#{16};{0} {2}// "foo"{0} {24}c"foo #\"# bar"{16};{0} {25}cr##"foo #"# bar"##{16};{0} {2}// foo #"# bar{0} {24}c"\x52"{16};{0} {24}c"R"{16};{0} {25}cr"R"{0} {2}// R{0} {24}c"\\x52"{16};{0} {25}cr"\x52"{0} {2}// \x52{0} {13}"foo"{16};{0} {14}r"foo"{0} {2}// foo{0} {13}"\"foo\""{16};{0} {14}r#""foo""#{16};{0} {2}// "foo"{0} {13}"foo #\"# bar"{16};{0} {14}r##"foo #"# bar"##{16};{0} {2}// foo #"# bar{0} {13}"\x52"{16};{0} {13}"R"{16};{0} {14}r"R"{0} {2}// R{0} {13}"\\x52"{16};{0} {14}r"\x52"{0} {2}// \x52{0} {13}"æ"{0} {2}// LATIN SMALL LETTER AE (U+00E6){0} {13}"\u{00E6}"{16};{0} {13}"\xC3\xA6"{16};tmpok_q575y/lexilla/test/examples/rust/SciTE.properties0000664000175000017500000000064214773064066023064 0ustar gusnangusnanlexer.*.rs=rust keywords.*.rs= \ alignof as be box break const continue crate do else enum extern false fn for if impl in let loop match mod mut offsetof once priv proc pub pure ref return self sizeof static struct super trait true type typeof unsafe unsized use virtual while yield keywords2.*.rs= \ bool char f32 f64 i16 i32 i64 i128 i8 int str u16 u32 u64 u128 u8 uint keywords3.*.rs=Self fold=1 fold.comment=1 tmpok_q575y/lexilla/test/examples/rust/Issue34.rs.styled0000664000175000017500000000036314773064066023107 0ustar gusnangusnan{3}/** * SCE_RUST_COMMENTBLOCKDOC */{0} {6}fn{0} {17}main{16}(){0} {16}{{0} {4}/// SCE_RUST_COMMENTLINEDOC{0} {19}println!{16}({13}"Hello, World!"{16});{0} {16}}{0} {2}// SCE_RUST_COMMENTLINE{0} {1}/* * SCE_RUST_COMMENTBLOCK */{0} tmpok_q575y/lexilla/test/examples/rust/Issue239.rs.folded0000664000175000017500000000016514773064066023127 0ustar gusnangusnan 2 400 401 + fn main() { 0 401 401 | let r#true = false; 0 401 401 | println!("{}", r#true); 0 401 400 | }tmpok_q575y/lexilla/test/examples/rust/Issue33.rs.folded0000664000175000017500000000030714773064066023035 0ustar gusnangusnan 2 400 401 + fn main() { 0 401 401 | let a: i128 = 42i128; 0 401 401 | let b: u128 = 1337u128; 0 401 401 | println!("{} + {} = {}", a, b, (a as u128) + b); 0 401 400 | } 1 400 400 tmpok_q575y/lexilla/test/examples/rust/Issue268.rs.folded0000664000175000017500000000233514773064066023132 0ustar gusnangusnan 0 400 400 // coding: utf-8 1 400 400 0 400 400 b"foo"; br"foo" // foo 0 400 400 b"\"foo\""; br#""foo""#; // "foo" 1 400 400 0 400 400 b"foo #\"# bar"; 0 400 400 br##"foo #"# bar"##; // foo #"# bar 1 400 400 0 400 400 b"\x52"; b"R"; br"R" // R 0 400 400 b"\\x52"; br"\x52" // \x52 1 400 400 0 400 400 c"æ" // LATIN SMALL LETTER AE (U+00E6) 0 400 400 c"\u{00E6}"; 0 400 400 c"\xC3\xA6"; 1 400 400 0 400 400 c"foo"; cr"foo" // foo 0 400 400 c"\"foo\""; cr#""foo""#; // "foo" 1 400 400 0 400 400 c"foo #\"# bar"; 0 400 400 cr##"foo #"# bar"##; // foo #"# bar 1 400 400 0 400 400 c"\x52"; c"R"; cr"R" // R 0 400 400 c"\\x52"; cr"\x52" // \x52 1 400 400 0 400 400 "foo"; r"foo" // foo 0 400 400 "\"foo\""; r#""foo""#; // "foo" 1 400 400 0 400 400 "foo #\"# bar"; 0 400 400 r##"foo #"# bar"##; // foo #"# bar 1 400 400 0 400 400 "\x52"; "R"; r"R" // R 0 400 400 "\\x52"; r"\x52" // \x52 1 400 400 0 400 400 "æ" // LATIN SMALL LETTER AE (U+00E6) 0 400 400 "\u{00E6}"; 0 400 400 "\xC3\xA6";tmpok_q575y/lexilla/test/examples/rust/Issue33.rs.styled0000664000175000017500000000047614773064066023113 0ustar gusnangusnan{6}fn{0} {17}main{16}(){0} {16}{{0} {6}let{0} {17}a{16}:{0} {7}i128{0} {16}={0} {5}42i128{16};{0} {6}let{0} {17}b{16}:{0} {7}u128{0} {16}={0} {5}1337u128{16};{0} {19}println!{16}({13}"{} + {} = {}"{16},{0} {17}a{16},{0} {17}b{16},{0} {16}({17}a{0} {6}as{0} {7}u128{16}){0} {16}+{0} {17}b{16});{0} {16}}{0} tmpok_q575y/lexilla/test/examples/rust/Issue34.rs.folded0000664000175000017500000000050514773064066023036 0ustar gusnangusnan 2 400 401 + /** 0 401 401 | * SCE_RUST_COMMENTBLOCKDOC 0 401 400 | */ 2 400 401 + fn main() { 0 401 401 | /// SCE_RUST_COMMENTLINEDOC 0 401 401 | println!("Hello, World!"); 0 401 400 | } 0 400 400 // SCE_RUST_COMMENTLINE 2 400 401 + /* 0 401 401 | * SCE_RUST_COMMENTBLOCK 0 401 400 | */ 1 400 400 tmpok_q575y/lexilla/test/examples/rust/Issue268.rs0000664000175000017500000000141114773064066021670 0ustar gusnangusnan// coding: utf-8 b"foo"; br"foo" // foo b"\"foo\""; br#""foo""#; // "foo" b"foo #\"# bar"; br##"foo #"# bar"##; // foo #"# bar b"\x52"; b"R"; br"R" // R b"\\x52"; br"\x52" // \x52 c"æ" // LATIN SMALL LETTER AE (U+00E6) c"\u{00E6}"; c"\xC3\xA6"; c"foo"; cr"foo" // foo c"\"foo\""; cr#""foo""#; // "foo" c"foo #\"# bar"; cr##"foo #"# bar"##; // foo #"# bar c"\x52"; c"R"; cr"R" // R c"\\x52"; cr"\x52" // \x52 "foo"; r"foo" // foo "\"foo\""; r#""foo""#; // "foo" "foo #\"# bar"; r##"foo #"# bar"##; // foo #"# bar "\x52"; "R"; r"R" // R "\\x52"; r"\x52" // \x52 "æ" // LATIN SMALL LETTER AE (U+00E6) "\u{00E6}"; "\xC3\xA6";tmpok_q575y/lexilla/test/examples/gui4cli/0000775000175000017500000000000014773064066020340 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/gui4cli/AllStyles.gui.styled0000664000175000017500000000140314773064066024263 0ustar gusnangusnan{2}/* Comment (2), followed by Default (0) */{0} {2}/* File does not include Line Comment (1) as that causes \r\n failures in test runner */{0} {2}/* Global (3) 'G4C' */{0} {3}G4C{0} MyGui {2}/* String (8) */{0} {3}Window{0} 10 10 200 300 {8}"My window"{0} {2}/* Event (4) */{0} {4}xOnLoad{0} {2}/* Command (7) */{0} {7}GuiOpen{0} MyGui {3}xButton{0} 10 10 100 20 {8}"Double it!"{0} {2}/* Attribute (5) */{0} {5}attr{0} frame sunk {7}Input{0} {8}"Enter a number"{0} var {2}/* Control (6) 'if', Operator (9) '$', '>', '=' */{0} {6}if{0} {9}${0}var {9}>{0} 9999 var {9}={0} 9999 {6}endif{0} var2 {9}={0} {9}${0}({9}${0}var * 2) {7}MsgBox{0} {8}"$var times 2 equals $var2"{0} OK/INFO {7}GuiQuit{0} #this tmpok_q575y/lexilla/test/examples/gui4cli/SciTE.properties0000664000175000017500000000040614773064066023425 0ustar gusnangusnanlexer.*.gui=gui4cli fold=1 #global keywords.*.gui=G4C WINDOW XBUTTON #event keywords2.*.gui=XONCLOSE XONLVDIR XONLOAD #attribute keywords3.*.gui=ATTR #control keywords4.*.gui=IF ELSE ENDIF GOSUB #command keywords5.*.gui=GUIOPEN GUIQUIT INPUT MSGBOX SETWINTITLE tmpok_q575y/lexilla/test/examples/gui4cli/AllStyles.gui0000664000175000017500000000112514773064066022761 0ustar gusnangusnan/* Comment (2), followed by Default (0) */ /* File does not include Line Comment (1) as that causes \r\n failures in test runner */ /* Global (3) 'G4C' */ G4C MyGui /* String (8) */ Window 10 10 200 300 "My window" /* Event (4) */ xOnLoad /* Command (7) */ GuiOpen MyGui xButton 10 10 100 20 "Double it!" /* Attribute (5) */ attr frame sunk Input "Enter a number" var /* Control (6) 'if', Operator (9) '$', '>', '=' */ if $var > 9999 var = 9999 endif var2 = $($var * 2) MsgBox "$var times 2 equals $var2" OK/INFO GuiQuit #this tmpok_q575y/lexilla/test/examples/gui4cli/AllStyles.gui.folded0000664000175000017500000000166414773064066024225 0ustar gusnangusnan 0 401 0 | /* Comment (2), followed by Default (0) */ 1 401 0 | 0 401 0 | /* File does not include Line Comment (1) as that causes \r\n failures in test runner */ 1 401 0 | 0 401 0 | /* Global (3) 'G4C' */ 2 400 0 + G4C MyGui 1 401 0 | 0 401 0 | /* String (8) */ 2 400 0 + Window 10 10 200 300 "My window" 1 401 0 | 0 401 0 | /* Event (4) */ 2 400 0 + xOnLoad 0 401 0 | /* Command (7) */ 0 401 0 | GuiOpen MyGui 1 401 0 | 2 400 0 + xButton 10 10 100 20 "Double it!" 0 401 0 | /* Attribute (5) */ 0 401 0 | attr frame sunk 0 401 0 | Input "Enter a number" var 0 401 0 | /* Control (6) 'if', Operator (9) '$', '>', '=' */ 0 401 0 | if $var > 9999 0 401 0 | var = 9999 0 401 0 | endif 0 401 0 | var2 = $($var * 2) 0 401 0 | MsgBox "$var times 2 equals $var2" OK/INFO 0 401 0 | GuiQuit #this 0 401 0 | tmpok_q575y/lexilla/test/examples/mysql/0000775000175000017500000000000014773064066020145 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/mysql/AllStyles.sql.folded0000664000175000017500000000326214773064066024041 0ustar gusnangusnan 0 400 400 -- Enumerate all styles: 0 to 22, except for 3 (variable) and 11 (string) which are not implemented 0 400 400 -- Hidden commands with other states (ored with ox40) are also possible inside /*! ... */ 1 400 400 0 400 400 /* commentline=2 */ 0 400 400 # comment 1 400 400 0 400 400 # default=0 0 400 400 # w 1 400 400 0 400 400 # comment=1 0 400 400 /* comment */ 1 400 400 0 400 400 # variable=3 is not implemented 0 400 400 @variable 1 400 400 0 400 400 # systemvariable=4 0 400 400 @@systemvariable 1 400 400 0 400 400 # knownsystemvariable=5 0 400 400 @@known 1 400 400 0 400 400 # number=6 0 400 400 6 1 400 400 0 400 400 # majorkeyword=7 0 400 400 select 1 400 400 0 400 400 # keyword=8 0 400 400 in 1 400 400 0 400 400 # databaseobject=9 0 400 400 object 1 400 400 0 400 400 # procedurekeyword=10 0 400 400 procedure 1 400 400 0 400 400 # string=11 is not implemented 1 400 400 0 400 400 # sqstring=12 0 400 400 'string' 1 400 400 0 400 400 # dqstring=13 0 400 400 "string" 1 400 400 0 400 400 # operator=14 0 400 400 + 1 400 400 0 400 400 # function=15 0 400 400 function() 1 400 400 0 400 400 # identifier=16 0 400 400 identifier 1 400 400 0 400 400 # quotedidentifier=17 0 400 400 `quoted` 1 400 400 0 400 400 # user1=18 0 400 400 user1 1 400 400 0 400 400 # user2=19 0 400 400 user2 1 400 400 0 400 400 # user3=20 0 400 400 user3 1 400 400 0 400 400 # hiddencommand=21 0 400 400 /*!*/ 1 400 400 0 400 400 # placeholder=22 0 400 400 <{placeholder>} 0 400 0 tmpok_q575y/lexilla/test/examples/mysql/SciTE.properties0000664000175000017500000000052414773064066023233 0ustar gusnangusnanlexer.*.sql=mysql keywords.*.sql=select keywords2.*.sql=in keywords3.*.sql=object keywords4.*.sql=function keywords5.*.sql=known keywords6.*.sql=procedure keywords7.*.sql=user1 keywords8.*.sql=user2 keywords9.*.sql=user3 lexer.sql.backticks.identifier=1 lexer.sql.numbersign.comment=1 lexer.sql.allow.dotted.word=1 fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/mysql/AllStyles.sql.styled0000664000175000017500000000200114773064066024076 0ustar gusnangusnan{2}-- Enumerate all styles: 0 to 22, except for 3 (variable) and 11 (string) which are not implemented -- Hidden commands with other states (ored with ox40) are also possible inside /*! ... */ {0} {1}/* commentline=2 */{0} {2}# comment {0} {2}# default=0 {0} {2}# w {0} {2}# comment=1 {1}/* comment */{0} {2}# variable=3 is not implemented {14}@{16}variable{0} {2}# systemvariable=4 {4}@@systemvariable{0} {2}# knownsystemvariable=5 {5}@@known{0} {2}# number=6 {6}6{0} {2}# majorkeyword=7 {7}select{0} {2}# keyword=8 {8}in{0} {2}# databaseobject=9 {9}object{0} {2}# procedurekeyword=10 {10}procedure{0} {2}# string=11 is not implemented {0} {2}# sqstring=12 {12}'string'{0} {2}# dqstring=13 {13}"string"{0} {2}# operator=14 {14}+{0} {2}# function=15 {15}function{14}(){0} {2}# identifier=16 {16}identifier{0} {2}# quotedidentifier=17 {17}`quoted`{0} {2}# user1=18 {18}user1{0} {2}# user2=19 {19}user2{0} {2}# user3=20 {20}user3{0} {2}# hiddencommand=21 {21}/*!*/{0} {2}# placeholder=22 {22}<{placeholder>} tmpok_q575y/lexilla/test/examples/mysql/AllStyles.sql0000664000175000017500000000142714773064066022606 0ustar gusnangusnan-- Enumerate all styles: 0 to 22, except for 3 (variable) and 11 (string) which are not implemented -- Hidden commands with other states (ored with ox40) are also possible inside /*! ... */ /* commentline=2 */ # comment # default=0 # w # comment=1 /* comment */ # variable=3 is not implemented @variable # systemvariable=4 @@systemvariable # knownsystemvariable=5 @@known # number=6 6 # majorkeyword=7 select # keyword=8 in # databaseobject=9 object # procedurekeyword=10 procedure # string=11 is not implemented # sqstring=12 'string' # dqstring=13 "string" # operator=14 + # function=15 function() # identifier=16 identifier # quotedidentifier=17 `quoted` # user1=18 user1 # user2=19 user2 # user3=20 user3 # hiddencommand=21 /*!*/ # placeholder=22 <{placeholder>} tmpok_q575y/lexilla/test/examples/latex/0000775000175000017500000000000014773064066020115 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/latex/Feature1358.tex0000664000175000017500000000040614773064066022553 0ustar gusnangusnan\begin{lstlisting}[language=make] # If no BOARD is found in the environment, use this default: BOARD ?= bluepill # To use chinese st-link v2 and ch340 dongle with bluepill ifeq ($(BOARD),bluepill) STLINK_VERSION=2 PORT_LINUX=/dev/ttyUSB0 endif \end{lstlisting} tmpok_q575y/lexilla/test/examples/latex/SciTE.properties0000664000175000017500000000002214773064066023174 0ustar gusnangusnanlexer.*.tex=latex tmpok_q575y/lexilla/test/examples/latex/AllStyles.tex.folded0000664000175000017500000000222314773064066024006 0ustar gusnangusnan 0 400 0 % Enumerate all styles: 0 to 12 0 400 0 % Not a valid laTeX file as entities are unbalanced and not semantically correct 0 400 0 % comment=4 0 400 0 0 400 0 % whitespace=0 0 400 0 text % 0 400 0 0 400 0 % command=1 0 400 0 \documentclass 0 400 0 0 400 0 % tag=2 2 400 0 + \begin{document} 0 401 0 | 0 401 0 | % tag closing=5 0 401 0 | \end{document} 0 400 0 0 400 0 % math=3 2 400 0 + \begin{math} 0 401 0 | E &= mc^2 0 401 0 | \end{math} 0 400 0 0 400 0 % math block=6 2 400 0 + \begin{align} 0 401 0 | E &= mc^2 0 401 0 | \end{align} 0 400 0 0 400 0 % comment block=7 2 400 0 + \begin{comment} 0 401 0 | A block comment 0 401 0 | \end{comment} 0 400 0 0 400 0 % verbatim=8 2 400 0 + \begin{verbatim} 0 401 0 | puts $foo 0 401 0 | \end{verbatim} 0 400 0 0 400 0 % short command=9 0 400 0 \(\) 0 400 0 0 400 0 % special=10 0 400 0 \# 0 400 0 0 400 0 % command optional argument=11 0 400 0 \x[12pt] 0 400 0 0 400 0 % error=12 0 400 0 \ 0 400 0 tmpok_q575y/lexilla/test/examples/latex/Feature1358.tex.styled0000664000175000017500000000043014773064066024053 0ustar gusnangusnan{1}\begin{2}{lstlisting}{8}[language=make] # If no BOARD is found in the environment, use this default: BOARD ?= bluepill # To use chinese st-link v2 and ch340 dongle with bluepill ifeq ($(BOARD),bluepill) STLINK_VERSION=2 PORT_LINUX=/dev/ttyUSB0 endif {1}\end{5}{lstlisting}{0} tmpok_q575y/lexilla/test/examples/latex/AllStyles.tex.styled0000664000175000017500000000140114773064066024052 0ustar gusnangusnan{4}% Enumerate all styles: 0 to 12{0} {4}% Not a valid laTeX file as entities are unbalanced and not semantically correct{0} {4}% comment=4{0} {4}% whitespace=0{0} text {4}%{0} {4}% command=1{0} {1}\documentclass{0} {4}% tag=2{0} {1}\begin{2}{document}{0} {4}% tag closing=5{0} {1}\end{5}{document}{0} {4}% math=3{0} {1}\begin{2}{math}{3} E &= mc^2 {1}\end{5}{math}{0} {4}% math block=6{0} {1}\begin{2}{align}{6} E &= mc^2 {1}\end{5}{align}{0} {4}% comment block=7{0} {1}\begin{2}{comment}{7} A block comment {1}\end{5}{comment}{0} {4}% verbatim=8{0} {1}\begin{2}{verbatim}{8} puts $foo {1}\end{5}{verbatim}{0} {4}% short command=9{0} {9}\(\){0} {4}% special=10{0} {10}\#{0} {4}% command optional argument=11{0} {1}\x{11}[12pt]{0} {4}% error=12{0} {12}\{0} tmpok_q575y/lexilla/test/examples/latex/AllStyles.tex0000664000175000017500000000104314773064066022551 0ustar gusnangusnan% Enumerate all styles: 0 to 12 % Not a valid laTeX file as entities are unbalanced and not semantically correct % comment=4 % whitespace=0 text % % command=1 \documentclass % tag=2 \begin{document} % tag closing=5 \end{document} % math=3 \begin{math} E &= mc^2 \end{math} % math block=6 \begin{align} E &= mc^2 \end{align} % comment block=7 \begin{comment} A block comment \end{comment} % verbatim=8 \begin{verbatim} puts $foo \end{verbatim} % short command=9 \(\) % special=10 \# % command optional argument=11 \x[12pt] % error=12 \ tmpok_q575y/lexilla/test/examples/latex/Feature1358.tex.folded0000664000175000017500000000062514773064066024012 0ustar gusnangusnan 2 400 0 + \begin{lstlisting}[language=make] 0 401 0 | # If no BOARD is found in the environment, use this default: 0 401 0 | BOARD ?= bluepill 0 401 0 | 0 401 0 | # To use chinese st-link v2 and ch340 dongle with bluepill 0 401 0 | ifeq ($(BOARD),bluepill) 0 401 0 | STLINK_VERSION=2 0 401 0 | PORT_LINUX=/dev/ttyUSB0 0 401 0 | endif 0 401 0 | \end{lstlisting} 0 400 0 tmpok_q575y/lexilla/test/examples/yaml/0000775000175000017500000000000014773064066017742 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/yaml/x.yaml0000664000175000017500000000013714773064066021076 0ustar gusnangusnan# comment key: value # comment colon:in:key: value hanging_value: value 1: 1 true: true tmpok_q575y/lexilla/test/examples/yaml/longline.yaml.styled0000664000175000017500000000217214773064066023742 0ustar gusnangusnan{1}# makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line {0} {1}# Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 {0} tmpok_q575y/lexilla/test/examples/yaml/SciTE.properties0000664000175000017500000000007314773064066023027 0ustar gusnangusnanlexer.*.yaml=yaml keywords.*.yaml=true false yes no fold=1 tmpok_q575y/lexilla/test/examples/yaml/x.yaml.styled0000664000175000017500000000023314773064066022376 0ustar gusnangusnan{1}# comment {0} {2}key{9}:{0} value {1}# comment {0} {2}colon:in:key{9}:{0} value {2}hanging_value{9}:{0} value {2}1{9}:{4} 1 {0} {2}true{9}:{3} true tmpok_q575y/lexilla/test/examples/yaml/longline.yaml.folded0000664000175000017500000000225714773064066023677 0ustar gusnangusnan 0 400 0 # makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line 1 400 0 0 400 0 # Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 1 400 0 0 400 0 tmpok_q575y/lexilla/test/examples/yaml/longline.yaml0000664000175000017500000000215614773064066022441 0ustar gusnangusnan# makefile lexer previously used fixed 1024-byte line buffer that would treat text after that as new line # Long line with 1025 bytes last 2 bytes colored as default 3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 12345678912345678 tmpok_q575y/lexilla/test/examples/yaml/x.yaml.folded0000664000175000017500000000041014773064066022324 0ustar gusnangusnan 0 400 0 # comment 1 400 0 0 400 0 key: value # comment 1 400 0 0 400 0 colon:in:key: value 1 400 0 2 400 0 + hanging_value: 0 402 0 | value 1 400 0 0 400 0 1: 1 1 400 0 0 400 0 true: true 0 400 0 tmpok_q575y/lexilla/test/examples/matlab/0000775000175000017500000000000014773064066020240 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/matlab/FoldPoints.m.matlab0000664000175000017500000000065614773064066023745 0ustar gusnangusnan% All the examples here should yield folding classdef % Some code end for % Some code end function % Some code end if % Some code elseif % Some code else % Some code end parfor % Some code end spmd % Some code end switch case % Some code case % Some code otherwise % Some code end try % Some code catch % Some code end while % Some code end tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.octave.styled0000664000175000017500000000155514773064066025123 0ustar gusnangusnan{1}% Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug{0} {1}% White space=0{0} {1}%{0} {1}% Comment=1{0} {1}% Line comment{0} {1}% Next line is comment in Ocatve but not Matlab{0} {1}# Octave comment{0} {1}%{ Block comment. %}{0} {1}% Command=2{0} {1}%{ Omitted as this places a style transiton between \r and \n !rmdir oldtests %}{0} {1}% Number=3{0} {3}33.3{0} {1}% Keyword=4{0} {4}global{0} {7}x{0} {1}% Single Quoted String=5{0} {5}'string'{0} {1}% Operator=6{0} {6}[{7}X{6},{7}Y{6}]{0} {6}={0} {7}meshgrid{6}(-{3}10{6}:{3}0.25{6}:{3}10{6},-{3}10{6}:{3}0.25{6}:{3}10{6});{0} {1}% Identifier=7{0} {7}identifier{0} {6}={0} {3}2{0} {1}% Double Quoted String=8{0} {8}"string"{0} {1}% This loop should fold{0} {4}for{0} {7}i{0} {6}={0} {3}1{6}:{3}5{0} {7}x{6}({7}i{6}){0} {6}={0} {3}3{0} {6}*{0} {7}i{6};{0} {4}end{0} tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.matlab.styled0000664000175000017500000000120114773064066027364 0ustar gusnangusnan{7}a{6}={8}""""{6};{0} {7}b{6}={3}1{6};{0} {7}c{6}={5}'\'{6};{0} {7}d{6}={3}2{6};{0} {7}e{6}={8}"\"{6};{0} {7}f{6}={3}3{6};{0} {1}%" this should be a comment (colored as such), instead it closes the string{0} {7}g{6}={8}"{0} {7}h{6}={3}123{6};{0} {1}%" this is a syntax error in Matlab (about 'g'),{0} {1}% followed by a valid assignment (of 'h'){0} {1}% Instead, 'h' is colored as part of the string{0} {1}% Octave terminates string at 3rd ", Matlab at 4th{0} {7}i{6}={8}"\"{0} {8}"; % "{0} {1}%{0} {1}% Matlab (unlike Octave) does not allow string continuation with an escape{0} {7}b{0} {6}={0} {8}"multi\{0} {7}line{8}"{0} {1}% end{0} tmpok_q575y/lexilla/test/examples/matlab/ClassDefinition.m.matlab0000664000175000017500000000310214773064066024727 0ustar gusnangusnanclassdef Foo < handle % A couple of properties blocks properties (SetAccess = private) Var1 Var2 end properties Var3 Var4 end methods (Static) function y = f1(x) % events, properties and methods are the valid idenifiers % in the function scope events = 1; properties = 2; y = x + events * properties; end % Any of these words are also valid functions' names inside % methods block function y = events(x) arguments x {mustBeNegative} end y = f2(x)*100; function b = f2(a) b = a + 5; end end end % Example events block events Event1 Event2 end end % Now, let's break some stuff classdef Bar properties % Though MATLAB won't execute such a code, events, properties % and methods are keywords here, because we're still in the class scope events end methods end end % Not allowed in MATLAB, but, technically, we're still in the class scope if condition1 if condition2 % Though we're in the class scope, lexel will recognize no % keywords here: to avoid the neccessaty to track nested scopes, % it just considers everything beyond level 2 of folding to be % a function scope methods events properties end end end tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.octave.folded0000664000175000017500000000067414773064066027353 0ustar gusnangusnan 0 400 400 % Ensure escape sequences still work in octave 0 400 400 % Octave terminates string at 3rd ", Matlab at 4th 0 400 400 i="\" "; % " % 1 400 400 1 400 400 0 400 400 % Octave allows string continuation with an escape 0 400 400 b = "multi\ 0 400 400 line" 1 400 400 0 400 400 % No escape so string ends at line end 0 400 400 c = "multi 0 400 400 line" 1 400 400 0 400 400 % end 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/ClassDefinition.m.matlab.folded0000664000175000017500000000502114773064066026165 0ustar gusnangusnan 2 400 401 + classdef Foo < handle 1 401 401 | 0 401 401 | % A couple of properties blocks 2 401 402 + properties (SetAccess = private) 0 402 402 | Var1 0 402 402 | Var2 0 402 401 | end 1 401 401 | 2 401 402 + properties 0 402 402 | Var3 0 402 402 | Var4 0 402 401 | end 1 401 401 | 2 401 402 + methods (Static) 2 402 403 + function y = f1(x) 0 403 403 | % events, properties and methods are the valid idenifiers 0 403 403 | % in the function scope 0 403 403 | events = 1; 0 403 403 | properties = 2; 0 403 403 | y = x + events * properties; 0 403 402 | end 1 402 402 | 0 402 402 | % Any of these words are also valid functions' names inside 0 402 402 | % methods block 2 402 403 + function y = events(x) 1 403 403 | 2 403 404 + arguments 0 404 404 | x {mustBeNegative} 0 404 403 | end 1 403 403 | 0 403 403 | y = f2(x)*100; 2 403 404 + function b = f2(a) 0 404 404 | b = a + 5; 0 404 403 | end 0 403 402 | end 0 402 401 | end 1 401 401 | 0 401 401 | % Example events block 2 401 402 + events 0 402 402 | Event1 0 402 402 | Event2 0 402 401 | end 0 401 400 | end 1 400 400 1 400 400 0 400 400 % Now, let's break some stuff 2 400 401 + classdef Bar 1 401 401 | 2 401 402 + properties 0 402 402 | % Though MATLAB won't execute such a code, events, properties 0 402 402 | % and methods are keywords here, because we're still in the class scope 2 402 403 + events 0 403 402 | end 1 402 402 | 2 402 403 + methods 0 403 402 | end 0 402 401 | end 1 401 401 | 0 401 401 | % Not allowed in MATLAB, but, technically, we're still in the class scope 2 401 402 + if condition1 2 402 403 + if condition2 0 403 403 | % Though we're in the class scope, lexel will recognize no 0 403 403 | % keywords here: to avoid the neccessaty to track nested scopes, 0 403 403 | % it just considers everything beyond level 2 of folding to be 0 403 403 | % a function scope 0 403 403 | methods 0 403 403 | events 0 403 403 | properties 0 403 402 | end 0 402 401 | end 1 401 401 | 1 401 401 | 0 401 400 | end 1 400 400 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.matlab0000664000175000017500000000065714773064066026077 0ustar gusnangusnana=""""; b=1; c='\'; d=2; e="\"; f=3; %" this should be a comment (colored as such), instead it closes the string g=" h=123; %" this is a syntax error in Matlab (about 'g'), % followed by a valid assignment (of 'h') % Instead, 'h' is colored as part of the string % Octave terminates string at 3rd ", Matlab at 4th i="\" "; % " % % Matlab (unlike Octave) does not allow string continuation with an escape b = "multi\ line" % end tmpok_q575y/lexilla/test/examples/matlab/FoldPoints.m.matlab.styled0000664000175000017500000000123014773064066025235 0ustar gusnangusnan{1}% All the examples here should yield folding{0} {4}classdef{0} {1}% Some code{0} {4}end{0} {4}for{0} {1}% Some code{0} {4}end{0} {4}function{0} {1}% Some code{0} {4}end{0} {4}if{0} {1}% Some code{0} {4}elseif{0} {1}% Some code{0} {4}else{0} {1}% Some code{0} {4}end{0} {4}parfor{0} {1}% Some code{0} {4}end{0} {4}spmd{0} {1}% Some code{0} {4}end{0} {4}switch{0} {4}case{0} {1}% Some code{0} {4}case{0} {1}% Some code{0} {4}otherwise{0} {1}% Some code{0} {4}end{0} {4}try{0} {1}% Some code{0} {4}catch{0} {1}% Some code{0} {4}end{0} {4}while{0} {1}% Some code{0} {4}end{0} tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.octave0000664000175000017500000000110414773064066023606 0ustar gusnangusnan% Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug % White space=0 % % Comment=1 % Line comment % Next line is comment in Ocatve but not Matlab # Octave comment %{ Block comment. %} % Command=2 %{ Omitted as this places a style transiton between \r and \n !rmdir oldtests %} % Number=3 33.3 % Keyword=4 global x % Single Quoted String=5 'string' % Operator=6 [X,Y] = meshgrid(-10:0.25:10,-10:0.25:10); % Identifier=7 identifier = 2 % Double Quoted String=8 "string" % This loop should fold for i = 1:5 x(i) = 3 * i; end tmpok_q575y/lexilla/test/examples/matlab/SciTE.properties0000664000175000017500000000037514773064066023332 0ustar gusnangusnanlexer.*.matlab=matlab keywords.*.matlab=end for global if break case catch classdef continue else elseif function otherwise parfor persistent return spmd switch try while lexer.*.octave=octave keywords.*.octave=end for global if fold=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.matlab.folded0000664000175000017500000000221514773064066025025 0ustar gusnangusnan 0 400 400 % Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug 1 400 400 0 400 400 % White space=0 0 400 400 % 1 400 400 0 400 400 % Comment=1 0 400 400 % Line comment 1 400 400 0 400 400 % Next line is comment in Ocatve but not Matlab 0 400 400 # Octave comment 1 400 400 0 400 400 %{ 0 400 400 Block comment. 0 400 400 %} 1 400 400 0 400 400 % Command=2 1 400 400 0 400 400 %{ 0 400 400 Omitted as this places a style transiton between \r and \n 0 400 400 !rmdir oldtests 0 400 400 %} 1 400 400 0 400 400 % Number=3 0 400 400 33.3 1 400 400 0 400 400 % Keyword=4 0 400 400 global x 1 400 400 0 400 400 % Single Quoted String=5 0 400 400 'string' 1 400 400 0 400 400 % Operator=6 0 400 400 [X,Y] = meshgrid(-10:0.25:10,-10:0.25:10); 1 400 400 0 400 400 % Identifier=7 0 400 400 identifier = 2 1 400 400 0 400 400 % Double Quoted String=8 0 400 400 "string" 1 400 400 0 400 400 % This loop should fold 2 400 401 + for i = 1:5 0 401 401 | x(i) = 3 * i; 0 401 400 | end 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/FoldPoints.m.matlab.folded0000664000175000017500000000205314773064066025172 0ustar gusnangusnan 0 400 400 % All the examples here should yield folding 1 400 400 2 400 401 + classdef 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + for 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + function 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + if 0 401 401 | % Some code 0 401 401 | elseif 0 401 401 | % Some code 0 401 401 | else 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + parfor 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + spmd 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + switch 0 401 401 | case 0 401 401 | % Some code 0 401 401 | case 0 401 401 | % Some code 0 401 401 | otherwise 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + try 0 401 401 | % Some code 0 401 401 | catch 0 401 401 | % Some code 0 401 400 | end 1 400 400 2 400 401 + while 0 401 401 | % Some code 0 401 400 | end 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/NumericLiterals.m.matlab0000664000175000017500000000057614773064066024767 0ustar gusnangusnand = 123; x = 0x123ABC; b = 0b010101; xs64 = 0x2As64; xs32 = 0x2As32; xs16 = 0x2As16; xs8 = 0x2As8; xu64 = 0x2Au64; xu32 = 0x2Au32; xu16 = 0x2Au16; xu8 = 0x2Au8; bs64 = 0b10s64; bs32 = 0b10s32; bs16 = 0b10s16; bs8 = 0b10s8; bu64 = 0b10u64; bu32 = 0b10u32; bu16 = 0b10u16; bu8 = 0b10u8; c = .1; c = 1.1; c = .1e1; c = 1.1e1; c = 1e1; c = 1i; c = 1j; c = .1e2j; c = 1e2j; tmpok_q575y/lexilla/test/examples/matlab/ClassDefinition.m.matlab.styled0000664000175000017500000000430414773064066026237 0ustar gusnangusnan{4}classdef{0} {7}Foo{0} {6}<{0} {7}handle{0} {1}% A couple of properties blocks{0} {4}properties{0} {6}({7}SetAccess{0} {6}={0} {7}private{6}){0} {7}Var1{0} {7}Var2{0} {4}end{0} {4}properties{0} {7}Var3{0} {7}Var4{0} {4}end{0} {4}methods{0} {6}({7}Static{6}){0} {4}function{0} {7}y{0} {6}={0} {7}f1{6}({7}x{6}){0} {1}% events, properties and methods are the valid idenifiers{0} {1}% in the function scope{0} {7}events{0} {6}={0} {3}1{6};{0} {7}properties{0} {6}={0} {3}2{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}events{0} {6}*{0} {7}properties{6};{0} {4}end{0} {1}% Any of these words are also valid functions' names inside{0} {1}% methods block{0} {4}function{0} {7}y{0} {6}={0} {7}events{6}({7}x{6}){0} {4}arguments{0} {7}x{0} {6}{{7}mustBeNegative{6}}{0} {4}end{0} {7}y{0} {6}={0} {7}f2{6}({7}x{6})*{3}100{6};{0} {4}function{0} {7}b{0} {6}={0} {7}f2{6}({7}a{6}){0} {7}b{0} {6}={0} {7}a{0} {6}+{0} {3}5{6};{0} {4}end{0} {4}end{0} {4}end{0} {1}% Example events block{0} {4}events{0} {7}Event1{0} {7}Event2{0} {4}end{0} {4}end{0} {1}% Now, let's break some stuff{0} {4}classdef{0} {7}Bar{0} {4}properties{0} {1}% Though MATLAB won't execute such a code, events, properties{0} {1}% and methods are keywords here, because we're still in the class scope{0} {4}events{0} {4}end{0} {4}methods{0} {4}end{0} {4}end{0} {1}% Not allowed in MATLAB, but, technically, we're still in the class scope{0} {4}if{0} {7}condition1{0} {4}if{0} {7}condition2{0} {1}% Though we're in the class scope, lexel will recognize no{0} {1}% keywords here: to avoid the neccessaty to track nested scopes,{0} {1}% it just considers everything beyond level 2 of folding to be{0} {1}% a function scope{0} {7}methods{0} {7}events{0} {7}properties{0} {4}end{0} {4}end{0} {4}end{0} tmpok_q575y/lexilla/test/examples/matlab/ArgumentsBlock.m.matlab0000664000175000017500000000415114773064066024576 0ustar gusnangusnan%% Correctly defined arguments block function y = foo (x) % Some comment here % And, maybe, here arguments x (1,2) {mustBeReal(x)} end y = x*2; arguments = 1; y = y + arguments; end %% No arguments block, "arguments" is used % as a variable name (identifier) % Prevent arguments from folding with an identifier function y = foo (x) % Some comment here x = x + 1; arguments = 10; y = x + arguments; end % Prevent arguments from folding with a number function y = foo (x) 4 arguments = 10; y = x + arguments; end % With a double quote string function y = foo (x) "test" arguments = 10; y = x + arguments; end % With a string function y = foo (x) 'test' arguments = 10; y = x + arguments; end % With a keyword function y = foo (x) if x == 0; return 0; end arguments = 10; y = x + arguments; end % With an operator (illegal syntax) function y = foo (x) * arguments = 10; y = x + arguments; end % Semicolon is equivalent to a comment function y = foo(x) ;;;;;;; arguments x end y = x + 2; end % Arguments block is illegal in nested functions, % but lexer should process it anyway function y = foo (x) arguments x (1,2) {mustBeReal(x)} end function y = foo (x) arguments x (1,2) {mustBeReal(x)} end var = 0; arguments = 5; y = arguments + x; end % Use as a variable, just in case arguments = 10; end % Erroneous use of arguments block function y = foo(x) % Some comment x = x + 1; arguments x end y = x; end % "arguments" is an argument name too function r = foo(x, arguments) arguments x arguments end r = bar(x, arguments{:}); end % Multiple arguments blocks function [a, b] = foo(x, y, varargin) arguments(Input) x (1,4) {mustBeReal} y (1,:) {mustBeInteger} = x(2:end); end arguments(Input, Repeating) varargin end arguments(Output) a (1,1) {mustBeReal} b (1,1) {mustBeNonNegative} end var = 10; arguments = {"now", "it's", "variable"}; [a, b] = bar(x, y, arguments); end % One line function with arguments block. % This code style is rarely used (if at all), but the % lexer shouldn't break function y = foo(x); arguments; x; end; y = bar(x); end tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.octave.folded0000664000175000017500000000221514773064066025046 0ustar gusnangusnan 0 400 400 % Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug 1 400 400 0 400 400 % White space=0 0 400 400 % 1 400 400 0 400 400 % Comment=1 0 400 400 % Line comment 1 400 400 0 400 400 % Next line is comment in Ocatve but not Matlab 0 400 400 # Octave comment 1 400 400 0 400 400 %{ 0 400 400 Block comment. 0 400 400 %} 1 400 400 0 400 400 % Command=2 1 400 400 0 400 400 %{ 0 400 400 Omitted as this places a style transiton between \r and \n 0 400 400 !rmdir oldtests 0 400 400 %} 1 400 400 0 400 400 % Number=3 0 400 400 33.3 1 400 400 0 400 400 % Keyword=4 0 400 400 global x 1 400 400 0 400 400 % Single Quoted String=5 0 400 400 'string' 1 400 400 0 400 400 % Operator=6 0 400 400 [X,Y] = meshgrid(-10:0.25:10,-10:0.25:10); 1 400 400 0 400 400 % Identifier=7 0 400 400 identifier = 2 1 400 400 0 400 400 % Double Quoted String=8 0 400 400 "string" 1 400 400 0 400 400 % This loop should fold 2 400 401 + for i = 1:5 0 401 401 | x(i) = 3 * i; 0 401 400 | end 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/ArgumentsBlock.m.matlab.styled0000664000175000017500000001027314773064066026103 0ustar gusnangusnan{1}%% Correctly defined arguments block{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {1}% Some comment here{0} {1}% And, maybe, here{0} {4}arguments{0} {7}x{0} {6}({3}1{6},{3}2{6}){0} {6}{{7}mustBeReal{6}({7}x{6})}{0} {4}end{0} {7}y{0} {6}={0} {7}x{6}*{3}2{6};{0} {7}arguments{0} {6}={0} {3}1{6};{0} {7}y{0} {6}={0} {7}y{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}%% No arguments block, "arguments" is used {0} {1}% as a variable name (identifier){0} {1}% Prevent arguments from folding with an identifier{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {1}% Some comment here{0} {7}x{0} {6}={0} {7}x{0} {6}+{0} {3}1{6};{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% Prevent arguments from folding with a number{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {3}4{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% With a double quote string{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {8}"test"{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% With a string{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {5}'test'{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% With a keyword{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {4}if{0} {7}x{0} {6}=={0} {3}0{6};{0} {4}return{0} {3}0{6};{0} {4}end{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% With an operator (illegal syntax){0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {6}*{0} {7}arguments{0} {6}={0} {3}10{6};{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {7}arguments{6};{0} {4}end{0} {1}% Semicolon is equivalent to a comment{0} {4}function{0} {7}y{0} {6}={0} {7}foo{6}({7}x{6}){0} {6};;;;;;;{0} {4}arguments{0} {7}x{0} {4}end{0} {7}y{0} {6}={0} {7}x{0} {6}+{0} {3}2{6};{0} {4}end{0} {1}% Arguments block is illegal in nested functions,{0} {1}% but lexer should process it anyway{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {4}arguments{0} {7}x{0} {6}({3}1{6},{3}2{6}){0} {6}{{7}mustBeReal{6}({7}x{6})}{0} {4}end{0} {4}function{0} {7}y{0} {6}={0} {7}foo{0} {6}({7}x{6}){0} {4}arguments{0} {7}x{0} {6}({3}1{6},{3}2{6}){0} {6}{{7}mustBeReal{6}({7}x{6})}{0} {4}end{0} {7}var{0} {6}={0} {3}0{6};{0} {7}arguments{0} {6}={0} {3}5{6};{0} {7}y{0} {6}={0} {7}arguments{0} {6}+{0} {7}x{6};{0} {4}end{0} {1}% Use as a variable, just in case{0} {7}arguments{0} {6}={0} {3}10{6};{0} {4}end{0} {1}% Erroneous use of arguments block{0} {4}function{0} {7}y{0} {6}={0} {7}foo{6}({7}x{6}){0} {1}% Some comment{0} {7}x{0} {6}={0} {7}x{0} {6}+{0} {3}1{6};{0} {7}arguments{0} {7}x{0} {4}end{0} {7}y{0} {6}={0} {7}x{6};{0} {4}end{0} {1}% "arguments" is an argument name too{0} {4}function{0} {7}r{0} {6}={0} {7}foo{6}({7}x{6},{0} {7}arguments{6}){0} {4}arguments{0} {7}x{0} {7}arguments{0} {4}end{0} {7}r{0} {6}={0} {7}bar{6}({7}x{6},{0} {7}arguments{6}{:});{0} {4}end{0} {1}% Multiple arguments blocks{0} {4}function{0} {6}[{7}a{6},{0} {7}b{6}]{0} {6}={0} {7}foo{6}({7}x{6},{0} {7}y{6},{0} {7}varargin{6}){0} {4}arguments{6}({7}Input{6}){0} {7}x{0} {6}({3}1{6},{3}4{6}){0} {6}{{7}mustBeReal{6}}{0} {7}y{0} {6}({3}1{6},:){0} {6}{{7}mustBeInteger{6}}{0} {6}={0} {7}x{6}({3}2{6}:{3}end{6});{0} {4}end{0} {4}arguments{6}({7}Input{6},{0} {7}Repeating{6}){0} {7}varargin{0} {4}end{0} {4}arguments{6}({7}Output{6}){0} {7}a{0} {6}({3}1{6},{3}1{6}){0} {6}{{7}mustBeReal{6}}{0} {7}b{0} {6}({3}1{6},{3}1{6}){0} {6}{{7}mustBeNonNegative{6}}{0} {4}end{0} {7}var{0} {6}={0} {3}10{6};{0} {7}arguments{0} {6}={0} {6}{{8}"now"{6},{0} {8}"it's"{6},{0} {8}"variable"{6}};{0} {6}[{7}a{6},{0} {7}b{6}]{0} {6}={0} {7}bar{6}({7}x{6},{0} {7}y{6},{0} {7}arguments{6});{0} {4}end{0} {1}% One line function with arguments block.{0} {1}% This code style is rarely used (if at all), but the{0} {1}% lexer shouldn't break{0} {4}function{0} {7}y{0} {6}={0} {7}foo{6}({7}x{6});{0} {4}arguments{6};{0} {7}x{6};{0} {4}end{6};{0} {7}y{0} {6}={0} {7}bar{6}({7}x{6});{0} {4}end{0} tmpok_q575y/lexilla/test/examples/matlab/ArgumentsBlock.m.matlab.folded0000664000175000017500000000755314773064066026043 0ustar gusnangusnan 0 400 400 %% Correctly defined arguments block 2 400 401 + function y = foo (x) 0 401 401 | % Some comment here 0 401 401 | % And, maybe, here 1 401 401 | 2 401 402 + arguments 0 402 402 | x (1,2) {mustBeReal(x)} 0 402 401 | end 1 401 401 | 0 401 401 | y = x*2; 0 401 401 | arguments = 1; 0 401 401 | y = y + arguments; 0 401 400 | end 1 400 400 0 400 400 %% No arguments block, "arguments" is used 0 400 400 % as a variable name (identifier) 0 400 400 % Prevent arguments from folding with an identifier 2 400 401 + function y = foo (x) 0 401 401 | % Some comment here 0 401 401 | x = x + 1; 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % Prevent arguments from folding with a number 2 400 401 + function y = foo (x) 0 401 401 | 4 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % With a double quote string 2 400 401 + function y = foo (x) 0 401 401 | "test" 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % With a string 2 400 401 + function y = foo (x) 0 401 401 | 'test' 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % With a keyword 2 400 401 + function y = foo (x) 2 401 402 + if x == 0; 0 402 402 | return 0; 0 402 401 | end 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % With an operator (illegal syntax) 2 400 401 + function y = foo (x) 0 401 401 | * 0 401 401 | arguments = 10; 0 401 401 | y = x + arguments; 0 401 400 | end 1 400 400 0 400 400 % Semicolon is equivalent to a comment 2 400 401 + function y = foo(x) 0 401 401 | ;;;;;;; 2 401 402 + arguments 0 402 402 | x 0 402 401 | end 0 401 401 | y = x + 2; 0 401 400 | end 1 400 400 0 400 400 % Arguments block is illegal in nested functions, 0 400 400 % but lexer should process it anyway 2 400 401 + function y = foo (x) 2 401 402 + arguments 0 402 402 | x (1,2) {mustBeReal(x)} 0 402 401 | end 1 401 401 | 2 401 402 + function y = foo (x) 2 402 403 + arguments 0 403 403 | x (1,2) {mustBeReal(x)} 0 403 402 | end 0 402 402 | var = 0; 0 402 402 | arguments = 5; 0 402 402 | y = arguments + x; 0 402 401 | end 1 401 401 | 0 401 401 | % Use as a variable, just in case 0 401 401 | arguments = 10; 0 401 400 | end 1 400 400 0 400 400 % Erroneous use of arguments block 2 400 401 + function y = foo(x) 0 401 401 | % Some comment 0 401 401 | x = x + 1; 0 401 401 | arguments 0 401 401 | x 0 401 400 | end 0 400 400 y = x; 0 400 3ff end 1 3ff 3ff 0 3ff 3ff % "arguments" is an argument name too 2 3ff 400 + function r = foo(x, arguments) 2 400 401 + arguments 0 401 401 | x 0 401 401 | arguments 0 401 400 | end 0 400 400 r = bar(x, arguments{:}); 0 400 3ff end 1 3ff 3ff 0 3ff 3ff % Multiple arguments blocks 2 3ff 400 + function [a, b] = foo(x, y, varargin) 1 400 400 2 400 401 + arguments(Input) 0 401 401 | x (1,4) {mustBeReal} 0 401 401 | y (1,:) {mustBeInteger} = x(2:end); 0 401 400 | end 1 400 400 2 400 401 + arguments(Input, Repeating) 0 401 401 | varargin 0 401 400 | end 1 400 400 2 400 401 + arguments(Output) 0 401 401 | a (1,1) {mustBeReal} 0 401 401 | b (1,1) {mustBeNonNegative} 0 401 400 | end 1 400 400 0 400 400 var = 10; 0 400 400 arguments = {"now", "it's", "variable"}; 1 400 400 0 400 400 [a, b] = bar(x, y, arguments); 1 400 400 0 400 3ff end 1 3ff 3ff 0 3ff 3ff % One line function with arguments block. 0 3ff 3ff % This code style is rarely used (if at all), but the 0 3ff 3ff % lexer shouldn't break 0 3ff 3ff function y = foo(x); arguments; x; end; y = bar(x); end 1 3ff 3ff tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.octave0000664000175000017500000000037114773064066026111 0ustar gusnangusnan% Ensure escape sequences still work in octave % Octave terminates string at 3rd ", Matlab at 4th i="\" "; % " % % Octave allows string continuation with an escape b = "multi\ line" % No escape so string ends at line end c = "multi line" % end tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.matlab0000664000175000017500000000110414773064066023565 0ustar gusnangusnan% Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug % White space=0 % % Comment=1 % Line comment % Next line is comment in Ocatve but not Matlab # Octave comment %{ Block comment. %} % Command=2 %{ Omitted as this places a style transiton between \r and \n !rmdir oldtests %} % Number=3 33.3 % Keyword=4 global x % Single Quoted String=5 'string' % Operator=6 [X,Y] = meshgrid(-10:0.25:10,-10:0.25:10); % Identifier=7 identifier = 2 % Double Quoted String=8 "string" % This loop should fold for i = 1:5 x(i) = 3 * i; end tmpok_q575y/lexilla/test/examples/matlab/AllStyles.m.matlab.styled0000664000175000017500000000156314773064066025101 0ustar gusnangusnan{1}% Examples of each style 0..8 except for SCE_MATLAB_COMMAND(2) which has a line ending bug{0} {1}% White space=0{0} {1}%{0} {1}% Comment=1{0} {1}% Line comment{0} {1}% Next line is comment in Ocatve but not Matlab{0} # {7}Octave{0} {7}comment{0} {1}%{ Block comment. %}{0} {1}% Command=2{0} {1}%{ Omitted as this places a style transiton between \r and \n !rmdir oldtests %}{0} {1}% Number=3{0} {3}33.3{0} {1}% Keyword=4{0} {4}global{0} {7}x{0} {1}% Single Quoted String=5{0} {5}'string'{0} {1}% Operator=6{0} {6}[{7}X{6},{7}Y{6}]{0} {6}={0} {7}meshgrid{6}(-{3}10{6}:{3}0.25{6}:{3}10{6},-{3}10{6}:{3}0.25{6}:{3}10{6});{0} {1}% Identifier=7{0} {7}identifier{0} {6}={0} {3}2{0} {1}% Double Quoted String=8{0} {8}"string"{0} {1}% This loop should fold{0} {4}for{0} {7}i{0} {6}={0} {3}1{6}:{3}5{0} {7}x{6}({7}i{6}){0} {6}={0} {3}3{0} {6}*{0} {7}i{6};{0} {4}end{0} tmpok_q575y/lexilla/test/examples/matlab/NumericLiterals.m.matlab.styled0000664000175000017500000000171214773064066026263 0ustar gusnangusnan{7}d{0} {6}={0} {3}123{6};{0} {7}x{0} {6}={0} {3}0x123ABC{6};{0} {7}b{0} {6}={0} {3}0b010101{6};{0} {7}xs64{0} {6}={0} {3}0x2As64{6};{0} {7}xs32{0} {6}={0} {3}0x2As32{6};{0} {7}xs16{0} {6}={0} {3}0x2As16{6};{0} {7}xs8{0} {6}={0} {3}0x2As8{6};{0} {7}xu64{0} {6}={0} {3}0x2Au64{6};{0} {7}xu32{0} {6}={0} {3}0x2Au32{6};{0} {7}xu16{0} {6}={0} {3}0x2Au16{6};{0} {7}xu8{0} {6}={0} {3}0x2Au8{6};{0} {7}bs64{0} {6}={0} {3}0b10s64{6};{0} {7}bs32{0} {6}={0} {3}0b10s32{6};{0} {7}bs16{0} {6}={0} {3}0b10s16{6};{0} {7}bs8{0} {6}={0} {3}0b10s8{6};{0} {7}bu64{0} {6}={0} {3}0b10u64{6};{0} {7}bu32{0} {6}={0} {3}0b10u32{6};{0} {7}bu16{0} {6}={0} {3}0b10u16{6};{0} {7}bu8{0} {6}={0} {3}0b10u8{6};{0} {7}c{0} {6}={0} {3}.1{6};{0} {7}c{0} {6}={0} {3}1.1{6};{0} {7}c{0} {6}={0} {3}.1e1{6};{0} {7}c{0} {6}={0} {3}1.1e1{6};{0} {7}c{0} {6}={0} {3}1e1{6};{0} {7}c{0} {6}={0} {3}1i{6};{0} {7}c{0} {6}={0} {3}1j{6};{0} {7}c{0} {6}={0} {3}.1e2j{6};{0} {7}c{0} {6}={0} {3}1e2j{6};{0} tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.octave.styled0000664000175000017500000000053114773064066027412 0ustar gusnangusnan{1}% Ensure escape sequences still work in octave{0} {1}% Octave terminates string at 3rd ", Matlab at 4th{0} {7}i{6}={8}"\" "{6};{0} {1}% " %{0} {1}% Octave allows string continuation with an escape{0} {7}b{0} {6}={0} {8}"multi\ line"{0} {1}% No escape so string ends at line end {0} {7}c{0} {6}={0} {8}"multi{0} {7}line{8}"{0} {1}% end{0} tmpok_q575y/lexilla/test/examples/matlab/NumericLiterals.m.matlab.folded0000664000175000017500000000136714773064066026222 0ustar gusnangusnan 0 400 400 d = 123; 0 400 400 x = 0x123ABC; 0 400 400 b = 0b010101; 0 400 400 xs64 = 0x2As64; 0 400 400 xs32 = 0x2As32; 0 400 400 xs16 = 0x2As16; 0 400 400 xs8 = 0x2As8; 0 400 400 xu64 = 0x2Au64; 0 400 400 xu32 = 0x2Au32; 0 400 400 xu16 = 0x2Au16; 0 400 400 xu8 = 0x2Au8; 0 400 400 bs64 = 0b10s64; 0 400 400 bs32 = 0b10s32; 0 400 400 bs16 = 0b10s16; 0 400 400 bs8 = 0b10s8; 0 400 400 bu64 = 0b10u64; 0 400 400 bu32 = 0b10u32; 0 400 400 bu16 = 0b10u16; 0 400 400 bu8 = 0b10u8; 0 400 400 c = .1; 0 400 400 c = 1.1; 0 400 400 c = .1e1; 0 400 400 c = 1.1e1; 0 400 400 c = 1e1; 0 400 400 c = 1i; 0 400 400 c = 1j; 0 400 400 c = .1e2j; 0 400 400 c = 1e2j; 1 400 400 tmpok_q575y/lexilla/test/examples/matlab/Issue18_EscapeSequence.m.matlab.folded0000664000175000017500000000131514773064066027323 0ustar gusnangusnan 0 400 400 a=""""; 0 400 400 b=1; 0 400 400 c='\'; 0 400 400 d=2; 0 400 400 e="\"; 0 400 400 f=3; 0 400 400 %" this should be a comment (colored as such), instead it closes the string 0 400 400 g=" 0 400 400 h=123; 0 400 400 %" this is a syntax error in Matlab (about 'g'), 0 400 400 % followed by a valid assignment (of 'h') 0 400 400 % Instead, 'h' is colored as part of the string 1 400 400 0 400 400 % Octave terminates string at 3rd ", Matlab at 4th 0 400 400 i="\" "; % " % 1 400 400 0 400 400 % Matlab (unlike Octave) does not allow string continuation with an escape 0 400 400 b = "multi\ 0 400 400 line" 1 400 400 0 400 400 % end 1 400 400 tmpok_q575y/lexilla/test/examples/toml/0000775000175000017500000000000014773064066017753 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/toml/SciTE.properties0000664000175000017500000000007414773064066023041 0ustar gusnangusnanlexer.*.toml=toml fold=1 keywords.*.toml=false inf nan true tmpok_q575y/lexilla/test/examples/toml/AllStyles.toml.styled0000664000175000017500000001542614773064066024077 0ustar gusnangusnan{1}# coding:utf-8 # This is a full-line comment {6}key{0} {8}={0} {10}"value"{0} {1}# This is a comment at the end of a line {6}another{0} {8}={0} {10}"# This is not a comment"{0} {6}key{0} {8}={0} {10}"value"{0} {6}bare_key{0} {8}={0} {10}"value"{0} {6}bare-key{0} {8}={0} {10}"value"{0} {6}1234{0} {8}={0} {10}"value"{0} {6}"127.0.0.1"{0} {8}={0} {10}"value"{0} {6}"character encoding"{0} {8}={0} {10}"value"{0} {6}"ÊŽÇÊž"{0} {8}={0} {10}"value"{0} {6}'key2'{0} {8}={0} {10}"value"{0} {6}'quoted "value"'{0} {8}={0} {10}"value"{0} {6}fruit{8}.{6}name{0} {8}={0} {10}"banana"{0} {1}# this is best practice {6}fruit{8}.{6} color{0} {8}={0} {10}"yellow"{0} {1}# same as fruit.color {6}fruit {8}.{6} flavor{0} {8}={0} {10}"banana"{0} {1}# same as fruit.flavor {0} {6}name{0} {8}={0} {10}"Orange"{0} {6}physical{8}.{6}color{0} {8}={0} {10}"orange"{0} {6}physical{8}.{6}shape{0} {8}={0} {10}"round"{0} {6}site{8}.{6}"google.com"{0} {8}={0} {3}true{0} {6}str{0} {8}={0} {10}"I'm a string. {13}\"{10}You can quote me{13}\"{10}. Name{13}\t{10}Jos{13}\u00E9\n{10}Location{13}\t{10}SF."{0} {6}str1{0} {8}={0} {12}""" Roses are red Violets are blue"""{0} {1}# The following strings are byte-for-byte equivalent: {6}str1{0} {8}={0} {10}"The quick brown fox jumps over the lazy dog."{0} {6}str2{0} {8}={0} {12}""" The quick brown \ fox jumps over \ the lazy dog."""{0} {6}str3{0} {8}={0} {12}"""\ The quick brown \ fox jumps over \ the lazy dog.\ """{0} {6}str4{0} {8}={0} {12}"""Here are two quotation marks: "". Simple enough."""{0} {1}# str5 = """Here are three quotation marks: """.""" # INVALID {6}str5{0} {8}={0} {12}"""Here are three quotation marks: ""{13}\"{12}."""{0} {6}str6{0} {8}={0} {12}"""Here are fifteen quotation marks: ""{13}\"{12}""{13}\"{12}""{13}\"{12}""{13}\"{12}""{13}\"{12}."""{0} {1}# "This," she said, "is just a pointless statement." {6}str7{0} {8}={0} {12}""""This," she said, "is just a pointless statement.""""{0} {1}# What you see is what you get. {6}winpath{0} {8}={0} {9}'C:\Users\nodejs\templates'{0} {6}winpath2{0} {8}={0} {9}'\\ServerX\admin$\system32\'{0} {6}quoted{0} {8}={0} {9}'Tom "Dubs" Preston-Werner'{0} {6}regex{0} {8}={0} {9}'<\i\c*\s*>'{0} {6}regex2{0} {8}={0} {11}'''I [dw]on't need \d{2} apples'''{0} {6}lines{0} {8}={0} {11}''' The first newline is trimmed in raw strings. All other whitespace is preserved. '''{0} {6}quot15{0} {8}={0} {11}'''Here are fifteen quotation marks: """""""""""""""'''{0} {1}# 'That,' she said, 'is still pointless.' {6}str{0} {8}={0} {11}''''That,' she said, 'is still pointless.''''{0} {6}int1{0} {8}={0} {8}+{4}99{0} {6}int2{0} {8}={0} {4}42{0} {6}int3{0} {8}={0} {4}0{0} {6}int4{0} {8}={0} {8}-{4}17{0} {6}int5{0} {8}={0} {4}1_000{0} {6}int6{0} {8}={0} {4}5_349_221{0} {6}int7{0} {8}={0} {4}53_49_221{0} {1}# Indian number system grouping {6}int8{0} {8}={0} {4}1_2_3_4_5{0} {1}# VALID but discouraged {0} {1}# hexadecimal with prefix `0x` {6}hex1{0} {8}={0} {4}0xDEADBEEF{0} {6}hex2{0} {8}={0} {4}0xdeadbeef{0} {6}hex3{0} {8}={0} {4}0xdead_beef{0} {1}# octal with prefix `0o` {6}oct1{0} {8}={0} {4}0o01234567{0} {6}oct2{0} {8}={0} {4}0o755{0} {1}# useful for Unix file permissions {0} {1}# binary with prefix `0b` {6}bin1{0} {8}={0} {4}0b11010110{0} {1}# fractional {6}flt1{0} {8}={0} {8}+{4}1.0{0} {6}flt2{0} {8}={0} {4}3.1415{0} {6}flt3{0} {8}={0} {8}-{4}0.01{0} {1}# exponent {6}flt4{0} {8}={0} {4}5e+22{0} {6}flt5{0} {8}={0} {4}1e06{0} {6}flt6{0} {8}={0} {8}-{4}2E-2{0} {1}# both {6}flt7{0} {8}={0} {4}6.626e-34{0} {6}flt8{0} {8}={0} {4}224_617.445_991_228{0} {1}# infinity {6}sf1{0} {8}={0} {3}inf{0} {1}# positive infinity {6}sf2{0} {8}={0} {8}+{3}inf{0} {1}# positive infinity {6}sf3{0} {8}={0} {8}-{3}inf{0} {1}# negative infinity {0} {1}# not a number {6}sf4{0} {8}={0} {3}nan{0} {1}# actual sNaN/qNaN encoding is implementation-specific {6}sf5{0} {8}={0} {8}+{3}nan{0} {1}# same as `nan` {6}sf6{0} {8}={0} {8}-{3}nan{0} {1}# valid, actual encoding is implementation-specific {0} {6}bool1{0} {8}={0} {3}true{0} {6}bool2{0} {8}={0} {3}false{0} {6}odt1{0} {8}={0} {14}1979-05-27T07:32:00Z{0} {6}odt2{0} {8}={0} {14}1979-05-27T00:32:00-07:00{0} {6}odt3{0} {8}={0} {14}1979-05-27T00:32:00.999999-07:00{0} {6}odt4{0} {8}={0} {14}1979-05-27 07:32:00Z{0} {6}ldt1{0} {8}={0} {14}1979-05-27T07:32:00{0} {6}ldt2{0} {8}={0} {14}1979-05-27T00:32:00.999999{0} {6}ld1{0} {8}={0} {14}1979-05-27{0} {6}lt1{0} {8}={0} {14}07:32:00{0} {6}lt2{0} {8}={0} {14}00:32:00.999999{0} {6}integers{0} {8}={0} {8}[{0} {4}1{8},{0} {4}2{8},{0} {4}3{0} {8}]{0} {6}colors{0} {8}={0} {8}[{0} {10}"red"{8},{0} {10}"yellow"{8},{0} {10}"green"{0} {8}]{0} {6}nested_arrays_of_ints{0} {8}={0} {8}[{0} {8}[{0} {4}1{8},{0} {4}2{0} {8}],{0} {8}[{4}3{8},{0} {4}4{8},{0} {4}5{8}]{0} {8}]{0} {6}nested_mixed_array{0} {8}={0} {8}[{0} {8}[{0} {4}1{8},{0} {4}2{0} {8}],{0} {8}[{10}"a"{8},{0} {10}"b"{8},{0} {10}"c"{8}]{0} {8}]{0} {6}string_array{0} {8}={0} {8}[{0} {10}"all"{8},{0} {9}'strings'{8},{0} {12}"""are the same"""{8},{0} {11}'''type'''{0} {8}]{0} {1}# Mixed-type arrays are allowed {6}numbers{0} {8}={0} {8}[{0} {4}0.1{8},{0} {4}0.2{8},{0} {4}0.5{8},{0} {4}1{8},{0} {4}2{8},{0} {4}5{0} {8}]{0} {6}contributors{0} {8}={0} {8}[{0} {10}"Foo Bar "{8},{0} {8}{{0} {6}name{0} {8}={0} {10}"Baz Qux"{8},{0} {6}email{0} {8}={0} {10}"bazqux@example.com"{8},{0} {6}url{0} {8}={0} {10}"https://example.com/bazqux"{0} {8}}{0} {8}]{0} {6}integers2{0} {8}={0} {8}[{0} {4}1{8},{0} {4}2{8},{0} {4}3{0} {8}]{0} {6}integers3{0} {8}={0} {8}[{0} {4}1{8},{0} {4}2{8},{0} {1}# this is ok {8}]{0} {5}[table-1] {6}key1{0} {8}={0} {10}"some string"{0} {6}key2{0} {8}={0} {4}123{0} {5}[table-2] {6}key1{0} {8}={0} {10}"another string"{0} {6}key2{0} {8}={0} {4}456{0} {5}[dog."tater.man"] {6}type{8}.{6}name{0} {8}={0} {10}"pug"{0} {5}[a.b.c]{0} {1}# this is best practice {5}[ d.e.f ]{0} {1}# same as [d.e.f] {5}[ g . h . i ]{0} {1}# same as [g.h.i] {5}[ j . "Êž" . 'l' ]{0} {1}# same as [j."Êž".'l'] {0} {5}[product] {6}type{0} {8}={0} {8}{{0} {6}name{0} {8}={0} {10}"Nail"{0} {8}}{0} {5}[[products]] {6}name{0} {8}={0} {10}"Hammer"{0} {6}sku{0} {8}={0} {4}738594937{0} {5}[[products]]{0} {1}# empty table within the array {0} {5}[[products]] {6}name{0} {8}={0} {10}"Nail"{0} {6}sku{0} {8}={0} {4}284758393{0} {6}points{0} {8}={0} {8}[{0} {8}{{0} {6}x{0} {8}={0} {4}1{8},{0} {6}y{0} {8}={0} {4}2{8},{0} {6}z{0} {8}={0} {4}3{0} {8}},{0} {8}{{0} {6}x{0} {8}={0} {4}7{8},{0} {6}y{0} {8}={0} {4}8{8},{0} {6}z{0} {8}={0} {4}9{0} {8}},{0} {8}{{0} {6}x{0} {8}={0} {4}2{8},{0} {6}y{0} {8}={0} {4}4{8},{0} {6}z{0} {8}={0} {4}8{0} {8}}{0} {8}]{0} {7}~~~~ = true {1}# invalid character in key {6}invalid{0} {1}# invalid, missing value {6}key{0} {8}={0} {2}identifier{0} {1}# also invalid, identifier must be one of true, false, inf, nan tmpok_q575y/lexilla/test/examples/toml/AllStyles.toml0000664000175000017500000001006714773064066022570 0ustar gusnangusnan# coding:utf-8 # This is a full-line comment key = "value" # This is a comment at the end of a line another = "# This is not a comment" key = "value" bare_key = "value" bare-key = "value" 1234 = "value" "127.0.0.1" = "value" "character encoding" = "value" "ÊŽÇÊž" = "value" 'key2' = "value" 'quoted "value"' = "value" fruit.name = "banana" # this is best practice fruit. color = "yellow" # same as fruit.color fruit . flavor = "banana" # same as fruit.flavor name = "Orange" physical.color = "orange" physical.shape = "round" site."google.com" = true str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF." str1 = """ Roses are red Violets are blue""" # The following strings are byte-for-byte equivalent: str1 = "The quick brown fox jumps over the lazy dog." str2 = """ The quick brown \ fox jumps over \ the lazy dog.""" str3 = """\ The quick brown \ fox jumps over \ the lazy dog.\ """ str4 = """Here are two quotation marks: "". Simple enough.""" # str5 = """Here are three quotation marks: """.""" # INVALID str5 = """Here are three quotation marks: ""\".""" str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" # "This," she said, "is just a pointless statement." str7 = """"This," she said, "is just a pointless statement."""" # What you see is what you get. winpath = 'C:\Users\nodejs\templates' winpath2 = '\\ServerX\admin$\system32\' quoted = 'Tom "Dubs" Preston-Werner' regex = '<\i\c*\s*>' regex2 = '''I [dw]on't need \d{2} apples''' lines = ''' The first newline is trimmed in raw strings. All other whitespace is preserved. ''' quot15 = '''Here are fifteen quotation marks: """""""""""""""''' # 'That,' she said, 'is still pointless.' str = ''''That,' she said, 'is still pointless.'''' int1 = +99 int2 = 42 int3 = 0 int4 = -17 int5 = 1_000 int6 = 5_349_221 int7 = 53_49_221 # Indian number system grouping int8 = 1_2_3_4_5 # VALID but discouraged # hexadecimal with prefix `0x` hex1 = 0xDEADBEEF hex2 = 0xdeadbeef hex3 = 0xdead_beef # octal with prefix `0o` oct1 = 0o01234567 oct2 = 0o755 # useful for Unix file permissions # binary with prefix `0b` bin1 = 0b11010110 # fractional flt1 = +1.0 flt2 = 3.1415 flt3 = -0.01 # exponent flt4 = 5e+22 flt5 = 1e06 flt6 = -2E-2 # both flt7 = 6.626e-34 flt8 = 224_617.445_991_228 # infinity sf1 = inf # positive infinity sf2 = +inf # positive infinity sf3 = -inf # negative infinity # not a number sf4 = nan # actual sNaN/qNaN encoding is implementation-specific sf5 = +nan # same as `nan` sf6 = -nan # valid, actual encoding is implementation-specific bool1 = true bool2 = false odt1 = 1979-05-27T07:32:00Z odt2 = 1979-05-27T00:32:00-07:00 odt3 = 1979-05-27T00:32:00.999999-07:00 odt4 = 1979-05-27 07:32:00Z ldt1 = 1979-05-27T07:32:00 ldt2 = 1979-05-27T00:32:00.999999 ld1 = 1979-05-27 lt1 = 07:32:00 lt2 = 00:32:00.999999 integers = [ 1, 2, 3 ] colors = [ "red", "yellow", "green" ] nested_arrays_of_ints = [ [ 1, 2 ], [3, 4, 5] ] nested_mixed_array = [ [ 1, 2 ], ["a", "b", "c"] ] string_array = [ "all", 'strings', """are the same""", '''type''' ] # Mixed-type arrays are allowed numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ] contributors = [ "Foo Bar ", { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" } ] integers2 = [ 1, 2, 3 ] integers3 = [ 1, 2, # this is ok ] [table-1] key1 = "some string" key2 = 123 [table-2] key1 = "another string" key2 = 456 [dog."tater.man"] type.name = "pug" [a.b.c] # this is best practice [ d.e.f ] # same as [d.e.f] [ g . h . i ] # same as [g.h.i] [ j . "Êž" . 'l' ] # same as [j."Êž".'l'] [product] type = { name = "Nail" } [[products]] name = "Hammer" sku = 738594937 [[products]] # empty table within the array [[products]] name = "Nail" sku = 284758393 points = [ { x = 1, y = 2, z = 3 }, { x = 7, y = 8, z = 9 }, { x = 2, y = 4, z = 8 } ] ~~~~ = true # invalid character in key invalid # invalid, missing value key = identifier # also invalid, identifier must be one of true, false, inf, nan tmpok_q575y/lexilla/test/examples/toml/AllStyles.toml.folded0000664000175000017500000001476714773064066024037 0ustar gusnangusnan 2 400 0 + # coding:utf-8 0 401 0 | # This is a full-line comment 0 400 0 key = "value" # This is a comment at the end of a line 0 400 0 another = "# This is not a comment" 0 400 0 0 400 0 key = "value" 0 400 0 bare_key = "value" 0 400 0 bare-key = "value" 0 400 0 1234 = "value" 0 400 0 0 400 0 "127.0.0.1" = "value" 0 400 0 "character encoding" = "value" 0 400 0 "ÊŽÇÊž" = "value" 0 400 0 'key2' = "value" 0 400 0 'quoted "value"' = "value" 0 400 0 0 400 0 fruit.name = "banana" # this is best practice 0 400 0 fruit. color = "yellow" # same as fruit.color 0 400 0 fruit . flavor = "banana" # same as fruit.flavor 0 400 0 0 400 0 name = "Orange" 0 400 0 physical.color = "orange" 0 400 0 physical.shape = "round" 0 400 0 site."google.com" = true 0 400 0 0 400 0 str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF." 0 400 0 0 400 0 str1 = """ 0 400 0 Roses are red 0 400 0 Violets are blue""" 0 400 0 0 400 0 # The following strings are byte-for-byte equivalent: 0 400 0 str1 = "The quick brown fox jumps over the lazy dog." 0 400 0 str2 = """ 0 400 0 The quick brown \ 0 400 0 0 400 0 0 400 0 fox jumps over \ 0 400 0 the lazy dog.""" 0 400 0 str3 = """\ 0 400 0 The quick brown \ 0 400 0 fox jumps over \ 0 400 0 the lazy dog.\ 0 400 0 """ 0 400 0 0 400 0 str4 = """Here are two quotation marks: "". Simple enough.""" 0 400 0 # str5 = """Here are three quotation marks: """.""" # INVALID 0 400 0 str5 = """Here are three quotation marks: ""\".""" 0 400 0 str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\".""" 0 400 0 # "This," she said, "is just a pointless statement." 0 400 0 str7 = """"This," she said, "is just a pointless statement."""" 0 400 0 0 400 0 # What you see is what you get. 0 400 0 winpath = 'C:\Users\nodejs\templates' 0 400 0 winpath2 = '\\ServerX\admin$\system32\' 0 400 0 quoted = 'Tom "Dubs" Preston-Werner' 0 400 0 regex = '<\i\c*\s*>' 0 400 0 0 400 0 regex2 = '''I [dw]on't need \d{2} apples''' 0 400 0 lines = ''' 0 400 0 The first newline is 0 400 0 trimmed in raw strings. 0 400 0 All other whitespace 0 400 0 is preserved. 0 400 0 ''' 0 400 0 0 400 0 quot15 = '''Here are fifteen quotation marks: """""""""""""""''' 0 400 0 # 'That,' she said, 'is still pointless.' 0 400 0 str = ''''That,' she said, 'is still pointless.'''' 0 400 0 0 400 0 int1 = +99 0 400 0 int2 = 42 0 400 0 int3 = 0 0 400 0 int4 = -17 0 400 0 0 400 0 int5 = 1_000 0 400 0 int6 = 5_349_221 0 400 0 int7 = 53_49_221 # Indian number system grouping 0 400 0 int8 = 1_2_3_4_5 # VALID but discouraged 0 400 0 0 400 0 # hexadecimal with prefix `0x` 0 400 0 hex1 = 0xDEADBEEF 0 400 0 hex2 = 0xdeadbeef 0 400 0 hex3 = 0xdead_beef 0 400 0 0 400 0 # octal with prefix `0o` 0 400 0 oct1 = 0o01234567 0 400 0 oct2 = 0o755 # useful for Unix file permissions 0 400 0 0 400 0 # binary with prefix `0b` 0 400 0 bin1 = 0b11010110 0 400 0 0 400 0 # fractional 0 400 0 flt1 = +1.0 0 400 0 flt2 = 3.1415 0 400 0 flt3 = -0.01 0 400 0 0 400 0 # exponent 0 400 0 flt4 = 5e+22 0 400 0 flt5 = 1e06 0 400 0 flt6 = -2E-2 0 400 0 0 400 0 # both 0 400 0 flt7 = 6.626e-34 0 400 0 0 400 0 flt8 = 224_617.445_991_228 0 400 0 0 400 0 # infinity 0 400 0 sf1 = inf # positive infinity 0 400 0 sf2 = +inf # positive infinity 0 400 0 sf3 = -inf # negative infinity 0 400 0 0 400 0 # not a number 0 400 0 sf4 = nan # actual sNaN/qNaN encoding is implementation-specific 0 400 0 sf5 = +nan # same as `nan` 0 400 0 sf6 = -nan # valid, actual encoding is implementation-specific 0 400 0 0 400 0 bool1 = true 0 400 0 bool2 = false 0 400 0 0 400 0 odt1 = 1979-05-27T07:32:00Z 0 400 0 odt2 = 1979-05-27T00:32:00-07:00 0 400 0 odt3 = 1979-05-27T00:32:00.999999-07:00 0 400 0 odt4 = 1979-05-27 07:32:00Z 0 400 0 0 400 0 ldt1 = 1979-05-27T07:32:00 0 400 0 ldt2 = 1979-05-27T00:32:00.999999 0 400 0 0 400 0 ld1 = 1979-05-27 0 400 0 0 400 0 lt1 = 07:32:00 0 400 0 lt2 = 00:32:00.999999 0 400 0 0 400 0 integers = [ 1, 2, 3 ] 0 400 0 colors = [ "red", "yellow", "green" ] 0 400 0 nested_arrays_of_ints = [ [ 1, 2 ], [3, 4, 5] ] 0 400 0 nested_mixed_array = [ [ 1, 2 ], ["a", "b", "c"] ] 0 400 0 string_array = [ "all", 'strings', """are the same""", '''type''' ] 0 400 0 0 400 0 # Mixed-type arrays are allowed 0 400 0 numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ] 0 400 0 contributors = [ 0 400 0 "Foo Bar ", 0 400 0 { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" } 0 400 0 ] 0 400 0 0 400 0 integers2 = [ 0 400 0 1, 2, 3 0 400 0 ] 0 400 0 0 400 0 integers3 = [ 0 400 0 1, 0 400 0 2, # this is ok 0 400 0 ] 0 400 0 2 400 0 + [table-1] 0 401 0 | key1 = "some string" 0 401 0 | key2 = 123 0 401 0 | 2 400 0 + [table-2] 0 401 0 | key1 = "another string" 0 401 0 | key2 = 456 0 401 0 | 2 401 0 + [dog."tater.man"] 0 402 0 | type.name = "pug" 0 402 0 | 0 402 0 | [a.b.c] # this is best practice 0 402 0 | [ d.e.f ] # same as [d.e.f] 0 402 0 | [ g . h . i ] # same as [g.h.i] 2 402 0 + [ j . "Êž" . 'l' ] # same as [j."Êž".'l'] 0 403 0 | 2 400 0 + [product] 0 401 0 | type = { name = "Nail" } 0 401 0 | 2 400 0 + [[products]] 0 401 0 | name = "Hammer" 0 401 0 | sku = 738594937 0 401 0 | 2 400 0 + [[products]] # empty table within the array 0 401 0 | 2 400 0 + [[products]] 0 401 0 | name = "Nail" 0 401 0 | sku = 284758393 0 401 0 | 0 401 0 | points = [ { x = 1, y = 2, z = 3 }, 0 401 0 | { x = 7, y = 8, z = 9 }, 0 401 0 | { x = 2, y = 4, z = 8 } ] 0 401 0 | 0 401 0 | ~~~~ = true # invalid character in key 0 401 0 | invalid # invalid, missing value 0 401 0 | key = identifier # also invalid, identifier must be one of true, false, inf, nan 0 401 0 | tmpok_q575y/lexilla/test/examples/pascal/0000775000175000017500000000000014773064066020243 5ustar gusnangusnantmpok_q575y/lexilla/test/examples/pascal/SomeExample.pas.folded0000664000175000017500000000251314773064066024424 0ustar gusnangusnan 0 400 0 // some example source code 1 400 0 2 400 0 + { 0 401 0 | SCE_PAS_DEFAULT=0 0 401 0 | SCE_PAS_IDENTIFIER=1 0 401 0 | SCE_PAS_COMMENT=2 0 401 0 | SCE_PAS_COMMENT2=3 0 401 0 | SCE_PAS_COMMENTLINE=4 0 401 0 | SCE_PAS_PREPROCESSOR=5 0 401 0 | SCE_PAS_PREPROCESSOR2=6 0 401 0 | SCE_PAS_NUMBER=7 0 401 0 | SCE_PAS_HEXNUMBER=8 0 401 0 | SCE_PAS_WORD=9 0 401 0 | SCE_PAS_STRING=10 0 401 0 | SCE_PAS_STRINGEOL=11 0 401 0 | SCE_PAS_CHARACTER=12 0 401 0 | SCE_PAS_OPERATOR=13 0 401 0 | SCE_PAS_ASM=14 0 401 0 | } 1 400 0 0 400 0 { --------------------------------------------------------------------------- } 0 400 0 function functionname(paramerter1: type1):result1; 0 400 0 var 0 400 0 i: LongInt; 2 400 0 + begin 0 401 0 | for i:=1 to 10 do 2 401 0 + begin 0 402 0 | writeln(i) 0 402 0 | end; 0 401 0 | result:=true; 0 401 0 | end; 0 400 0 { --------------------------------------------------------------------------- } 0 400 0 procedure procedurename(parameter2: type2); 0 400 0 var 0 400 0 i: LongInt; 2 400 0 + begin 0 401 0 | for i:=1 to 10 do 2 401 0 + begin 0 402 0 | writeln(i) 0 402 0 | end; 0 401 0 | end; 1 400 0 tmpok_q575y/lexilla/test/examples/pascal/AllStyles.pas0000664000175000017500000000200714773064066022663 0ustar gusnangusnan// Enumerate all primary styles: 0 to 14 { SCE_PAS_DEFAULT=0 SCE_PAS_IDENTIFIER=1 SCE_PAS_COMMENT=2 SCE_PAS_COMMENT2=3 SCE_PAS_COMMENTLINE=4 SCE_PAS_PREPROCESSOR=5 SCE_PAS_PREPROCESSOR2=6 SCE_PAS_NUMBER=7 SCE_PAS_HEXNUMBER=8 SCE_PAS_WORD=9 SCE_PAS_STRING=10 SCE_PAS_STRINGEOL=11 SCE_PAS_CHARACTER=12 SCE_PAS_OPERATOR=13 SCE_PAS_ASM=14 } // default=0 // identifier=1 function functionname(var paramerter1: type1):result1; procedure procedurename(const parameter2: type2); // comment=2 {comment text} // comment2=3 (* comment text *) // commentline=4 // example line // preprocessor=5 {$DEFINE xyz} {$IFDEF xyz} codeblock 1 {$else} codeblock 2 {$endif} // preprocessor2=6 (*$DEFINE xyz*) // number=7 123 1.23 -123 -12.3 +123 123 1.23e2 -1.23E2 // hexnumber=8 $123 $123ABCDEF $ABCDEF123 // word=9 absolute abstract and array as // string=10 'string' // stringeol=11 'string // character=12 #65 // operator=13 $ & * + / < = > ^ // asm asm this is inside assembler end tmpok_q575y/lexilla/test/examples/pascal/SciTE.properties0000664000175000017500000000161114773064066023327 0ustar gusnangusnan# coding: utf-8 lexer.*.pas=pascal keywords.*.pas=absolute abstract and array as asm assembler automated begin case \ cdecl class const constructor delayed deprecated destructor dispid dispinterface \ div do downto dynamic else end except experimental export exports external far \ file final finalization finally for forward function goto helper if \ implementation in inherited initialization inline interface is label library \ message mod near nil not object of on operator or out overload override packed \ pascal platform private procedure program property protected public published \ raise record reference register reintroduce repeat resourcestring safecall \ sealed set shl shr static stdcall strict string then threadvar to try type unit \ unsafe until uses var varargs virtual while winapi with xor lexer.pascal.smart.highlighting=1 fold=1 fold.preprocessor=1 fold.comment=1 fold.compact=1 tmpok_q575y/lexilla/test/examples/pascal/AllStyles.pas.styled0000664000175000017500000000265514773064066024177 0ustar gusnangusnan{4}// Enumerate all primary styles: 0 to 14 {0} {2}{ SCE_PAS_DEFAULT=0 SCE_PAS_IDENTIFIER=1 SCE_PAS_COMMENT=2 SCE_PAS_COMMENT2=3 SCE_PAS_COMMENTLINE=4 SCE_PAS_PREPROCESSOR=5 SCE_PAS_PREPROCESSOR2=6 SCE_PAS_NUMBER=7 SCE_PAS_HEXNUMBER=8 SCE_PAS_WORD=9 SCE_PAS_STRING=10 SCE_PAS_STRINGEOL=11 SCE_PAS_CHARACTER=12 SCE_PAS_OPERATOR=13 SCE_PAS_ASM=14 }{0} {4}// default=0 {0} {4}// identifier=1 {9}function{0} {1}functionname{13}({9}var{0} {1}paramerter1{13}:{0} {1}type1{13}):{1}result1{13};{0} {9}procedure{0} {1}procedurename{13}({9}const{0} {1}parameter2{13}:{0} {1}type2{13});{0} {4}// comment=2 {2}{comment text}{0} {4}// comment2=3 {3}(* comment text *){0} {4}// commentline=4 // example line {0} {4}// preprocessor=5 {5}{$DEFINE xyz}{0} {5}{$IFDEF xyz}{0} {1}codeblock{0} {7}1{0} {5}{$else}{0} {1}codeblock{0} {7}2{0} {5}{$endif}{0} {4}// preprocessor2=6 {6}(*$DEFINE xyz*){0} {4}// number=7 {7}123{0} {7}1.23{0} {13}-{7}123{0} {13}-{7}12.3{0} {13}+{7}123{0} {7}123{0} {7}1.23e2{0} {13}-{7}1.23E2{0} {4}// hexnumber=8 {8}$123{0} {8}$123ABCDEF{0} {8}$ABCDEF123{0} {4}// word=9 {9}absolute{0} {9}abstract{0} {9}and{0} {9}array{0} {9}as{0} {4}// string=10 {10}'string'{0} {4}// stringeol=11 {11}'string {0} {4}// character=12 {12}#65{0} {4}// operator=13 {8}${0} {13}&{0} {13}*{0} {13}+{0} {13}/{0} {13}<{0} {13}={0} {13}>{0} {13}^{0} {4}// asm {9}asm{14} this is inside assembler {9}end{0} tmpok_q575y/lexilla/test/examples/pascal/AllStyles.pas.folded0000664000175000017500000000407614773064066024127 0ustar gusnangusnan 0 400 0 // Enumerate all primary styles: 0 to 14 1 400 0 2 400 0 + { 0 401 0 | SCE_PAS_DEFAULT=0 0 401 0 | SCE_PAS_IDENTIFIER=1 0 401 0 | SCE_PAS_COMMENT=2 0 401 0 | SCE_PAS_COMMENT2=3 0 401 0 | SCE_PAS_COMMENTLINE=4 0 401 0 | SCE_PAS_PREPROCESSOR=5 0 401 0 | SCE_PAS_PREPROCESSOR2=6 0 401 0 | SCE_PAS_NUMBER=7 0 401 0 | SCE_PAS_HEXNUMBER=8 0 401 0 | SCE_PAS_WORD=9 0 401 0 | SCE_PAS_STRING=10 0 401 0 | SCE_PAS_STRINGEOL=11 0 401 0 | SCE_PAS_CHARACTER=12 0 401 0 | SCE_PAS_OPERATOR=13 0 401 0 | SCE_PAS_ASM=14 0 401 0 | } 1 400 0 0 400 0 // default=0 1 400 0 0 400 0 // identifier=1 0 400 0 function functionname(var paramerter1: type1):result1; 0 400 0 procedure procedurename(const parameter2: type2); 1 400 0 0 400 0 // comment=2 0 400 0 {comment text} 1 400 0 0 400 0 // comment2=3 0 400 0 (* comment text *) 1 400 0 2 400 0 + // commentline=4 0 401 0 | // example line 1 400 0 0 400 0 // preprocessor=5 0 400 0 {$DEFINE xyz} 1 400 0 2 400 0 + {$IFDEF xyz} 0 401 0 | codeblock 1 0 401 0 | {$else} 0 401 0 | codeblock 2 0 401 0 | {$endif} 1 400 0 0 400 0 // preprocessor2=6 0 400 0 (*$DEFINE xyz*) 1 400 0 0 400 0 // number=7 0 400 0 123 0 400 0 1.23 0 400 0 -123 0 400 0 -12.3 0 400 0 +123 0 400 0 123 0 400 0 1.23e2 0 400 0 -1.23E2 1 400 0 0 400 0 // hexnumber=8 0 400 0 $123 0 400 0 $123ABCDEF 0 400 0 $ABCDEF123 1 400 0 0 400 0 // word=9 0 400 0 absolute abstract and array as 1 400 0 0 400 0 // string=10 0 400 0 'string' 1 400 0 0 400 0 // stringeol=11 0 400 0 'string 1 400 0 0 400 0 // character=12 0 400 0 #65 1 400 0 0 400 0 // operator=13 0 400 0 $ & * + / < = > ^ 1 400 0 0 400 0 // asm 2 400 0 + asm 0 401 0 | this is 0 401 0 | inside assembler 0 401 0 | end 1 400 0 tmpok_q575y/lexilla/test/examples/pascal/SomeExample.pas0000664000175000017500000000145114773064066023170 0ustar gusnangusnan// some example source code { SCE_PAS_DEFAULT=0 SCE_PAS_IDENTIFIER=1 SCE_PAS_COMMENT=2 SCE_PAS_COMMENT2=3 SCE_PAS_COMMENTLINE=4 SCE_PAS_PREPROCESSOR=5 SCE_PAS_PREPROCESSOR2=6 SCE_PAS_NUMBER=7 SCE_PAS_HEXNUMBER=8 SCE_PAS_WORD=9 SCE_PAS_STRING=10 SCE_PAS_STRINGEOL=11 SCE_PAS_CHARACTER=12 SCE_PAS_OPERATOR=13 SCE_PAS_ASM=14 } { --------------------------------------------------------------------------- } function functionname(paramerter1: type1):result1; var i: LongInt; begin for i:=1 to 10 do begin writeln(i) end; result:=true; end; { --------------------------------------------------------------------------- } procedure procedurename(parameter2: type2); var i: LongInt; begin for i:=1 to 10 do begin writeln(i) end; end; tmpok_q575y/lexilla/test/examples/pascal/CodeFolding.pas.styled0000664000175000017500000000454714773064066024442 0ustar gusnangusnan{4}// tests for code folding {0} {4}// multi line comments {2}{ line1 line2 }{0} {4}// begin .. end {9}begin{0} {1}some{0} {1}commands{0} {9}end{13};{0} {9}record{0} {1}test{0} {1}var1{13}:{0} {1}type1{13};{0} {1}var2{13}:{0} {1}type2{13};{0} {9}end{13};{0} {4}//record {0} {4}//asm {9}asm{14} some statement {9}end{13};{0} {4}//asm {0} {4}//try (from https://wiki.freepascal.org/Try) {9}try{0} {4}// code that might generate an exception {9}except{0} {4}// will only be executed in case of an exception {0} {9}on{0} {1}E{13}:{0} {1}EDatabaseError{0} {9}do{0} {1}ShowMessage{13}({0} {10}'Database error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0} {9}on{0} {1}E{13}:{0} {1}Exception{0} {9}do{0} {1}ShowMessage{13}({0} {10}'Error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0} {9}end{13};{0} {4}//try nested (from https://wiki.freepascal.org/Try) {9}try{0} {9}try{0} {4}// code dealing with database that might generate an exception {0} {9}except{0} {4}// will only be executed in case of an exception {0} {9}on{0} {1}E{13}:{0} {1}EDatabaseError{0} {9}do{0} {1}ShowMessage{13}({0} {10}'Database error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0} {9}on{0} {1}E{13}:{0} {1}Exception{0} {9}do{0} {1}ShowMessage{13}({0} {10}'Error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0} {9}end{13};{0} {9}finally{0} {4}// clean up database-related resources {9}end{13};{0} {4}//case {9}case{0} {1}x{0} {9}of{0} {7}1{13}:{0} {9}do{0} {1}something{13};{0} {7}2{13}:{0} {9}do{0} {1}some{0} {1}other{0} {1}thing{13};{0} {9}else{0} {9}do{0} {1}default{13};{0} {9}end{13};{0} {4}//case {0} {4}//if then else {9}if{0} {1}x{13}={1}y{0} {9}then{0} {9}do{0} {1}something{13};{0} {9}else{0} {9}do{0} {1}some{0} {1}other{0} {1}thing{13};{0} {4}//for loop {9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0} {1}writeln{13}({1}i{13}){0} {4}//do until {9}repeat{0} {1}write{13}({1}a{13});{0} {1}i{13}:={1}i{13}+{7}1{13};{0} {9}until{0} {1}i{13}>{7}10{13};{0} {4}//preprocessor if, else, endif {5}{$DEFINE label}{0} {5}{$IFDEF label}{0} {1}command{0} {7}1{0} {5}{$ELSE}{0} {1}command{0} {7}2{0} {5}{$ENDIF}{0} tmpok_q575y/lexilla/test/examples/pascal/CodeFolding.pas0000664000175000017500000000254114773064066023127 0ustar gusnangusnan// tests for code folding // multi line comments { line1 line2 } // begin .. end begin some commands end; record test var1: type1; var2: type2; end; //record //asm asm some statement end; //asm //try (from https://wiki.freepascal.org/Try) try // code that might generate an exception except // will only be executed in case of an exception on E: EDatabaseError do ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message ); on E: Exception do ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message ); end; //try nested (from https://wiki.freepascal.org/Try) try try // code dealing with database that might generate an exception except // will only be executed in case of an exception on E: EDatabaseError do ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message ); on E: Exception do ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message ); end; finally // clean up database-related resources end; //case case x of 1: do something; 2: do some other thing; else do default; end; //case //if then else if x=y then do something; else do some other thing; //for loop for i:=1 to 10 do writeln(i) //do until repeat write(a); i:=i+1; until i>10; //preprocessor if, else, endif {$DEFINE label} {$IFDEF label} command 1 {$ELSE} command 2 {$ENDIF} tmpok_q575y/lexilla/test/examples/pascal/CodeFolding.pas.folded0000664000175000017500000000457614773064066024375 0ustar gusnangusnan 0 400 0 // tests for code folding 1 400 0 0 400 0 // multi line comments 2 400 0 + { 0 401 0 | line1 0 401 0 | line2 0 401 0 | } 1 400 0 0 400 0 // begin .. end 2 400 0 + begin 0 401 0 | some commands 0 401 0 | end; 1 400 0 2 400 0 + record test 0 401 0 | var1: type1; 0 401 0 | var2: type2; 0 401 0 | end; //record 1 400 0 0 400 0 //asm 2 400 0 + asm 0 401 0 | some statement 0 401 0 | end; //asm 1 400 0 0 400 0 //try (from https://wiki.freepascal.org/Try) 2 400 0 + try 0 401 0 | // code that might generate an exception 0 401 0 | except 0 401 0 | // will only be executed in case of an exception 0 401 0 | on E: EDatabaseError do 0 401 0 | ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message ); 0 401 0 | on E: Exception do 0 401 0 | ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message ); 0 401 0 | end; 1 400 0 0 400 0 //try nested (from https://wiki.freepascal.org/Try) 2 400 0 + try 2 401 0 + try 0 402 0 | // code dealing with database that might generate an exception 0 402 0 | except 0 402 0 | // will only be executed in case of an exception 0 402 0 | on E: EDatabaseError do 0 402 0 | ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message ); 0 402 0 | on E: Exception do 0 402 0 | ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message ); 0 402 0 | end; 0 401 0 | finally 0 401 0 | // clean up database-related resources 0 401 0 | end; 1 400 0 0 400 0 //case 2 400 0 + case x of 0 401 0 | 1: do something; 0 401 0 | 2: do some other thing; 0 401 0 | else 0 401 0 | do default; 0 401 0 | end; //case 1 400 0 0 400 0 //if then else 0 400 0 if x=y then 0 400 0 do something; 0 400 0 else 0 400 0 do some other thing; 1 400 0 0 400 0 //for loop 0 400 0 for i:=1 to 10 do 0 400 0 writeln(i) 1 400 0 0 400 0 //do until 0 400 0 repeat 0 400 0 write(a); 0 400 0 i:=i+1; 0 400 0 until i>10; 1 400 0 0 400 0 //preprocessor if, else, endif 0 400 0 {$DEFINE label} 2 400 0 + {$IFDEF label} 0 401 0 | command 1 0 401 0 | {$ELSE} 0 401 0 | command 2 0 401 0 | {$ENDIF} 1 400 0 tmpok_q575y/lexilla/test/examples/pascal/SomeExample.pas.styled0000664000175000017500000000217314773064066024475 0ustar gusnangusnan{4}// some example source code {0} {2}{ SCE_PAS_DEFAULT=0 SCE_PAS_IDENTIFIER=1 SCE_PAS_COMMENT=2 SCE_PAS_COMMENT2=3 SCE_PAS_COMMENTLINE=4 SCE_PAS_PREPROCESSOR=5 SCE_PAS_PREPROCESSOR2=6 SCE_PAS_NUMBER=7 SCE_PAS_HEXNUMBER=8 SCE_PAS_WORD=9 SCE_PAS_STRING=10 SCE_PAS_STRINGEOL=11 SCE_PAS_CHARACTER=12 SCE_PAS_OPERATOR=13 SCE_PAS_ASM=14 }{0} {2}{ --------------------------------------------------------------------------- }{0} {9}function{0} {1}functionname{13}({1}paramerter1{13}:{0} {1}type1{13}):{1}result1{13};{0} {9}var{0} {1}i{13}:{0} {1}LongInt{13};{0} {9}begin{0} {9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0} {9}begin{0} {1}writeln{13}({1}i{13}){0} {9}end{13};{0} {1}result{13}:={1}true{13};{0} {9}end{13};{0} {2}{ --------------------------------------------------------------------------- }{0} {9}procedure{0} {1}procedurename{13}({1}parameter2{13}:{0} {1}type2{13});{0} {9}var{0} {1}i{13}:{0} {1}LongInt{13};{0} {9}begin{0} {9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0} {9}begin{0} {1}writeln{13}({1}i{13}){0} {9}end{13};{0} {9}end{13};{0} tmpok_q575y/lexilla/test/TestLexers.vcxproj0000664000175000017500000002146514773064066020711 0ustar gusnangusnan Debug Win32 Release Win32 Debug x64 Release x64 16.0 {2E0BBD6B-4BC8-4A6C-9DDA-199C27899335} Win32Proj lexillatest 10.0 Application true v142 Unicode Application false v142 true Unicode Application true v142 Unicode Application false v142 true Unicode true ..\..\..\..\..\..\..\Users\Neil\NeilRules.ruleset true AllRules.ruleset true false ..\..\..\..\..\..\..\Users\Neil\NeilRules.ruleset false ..\..\..\..\..\..\..\Users\Neil\NeilRules.ruleset Level4 Disabled true WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) true ..\..\scintilla\include;..\include;..\access;%(AdditionalIncludeDirectories) stdcpplatest Console true Level4 Disabled true _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true ..\..\scintilla\include;..\include;..\access;%(AdditionalIncludeDirectories) stdcpplatest Console true Level4 MaxSpeed true true true WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true ..\..\scintilla\include;..\include;..\access;%(AdditionalIncludeDirectories) stdcpplatest Console true true true Level4 MaxSpeed true true true NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true ..\..\scintilla\include;..\include;..\access;%(AdditionalIncludeDirectories) stdcpplatest Console true true true tmpok_q575y/lexilla/test/TestDocument.h0000664000175000017500000000513614773064066017756 0ustar gusnangusnan// Lexilla lexer library /** @file TestDocument.h ** Lexer testing. **/ // Copyright 2019 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #ifndef TESTDOCUMENT_H #define TESTDOCUMENT_H std::u32string UTF32FromUTF8(std::string_view svu8); class TestDocument : public Scintilla::IDocument { std::string text; std::string textStyles; std::vector lineStarts; std::vector lineStates; std::vector lineLevels; Sci_Position endStyled=0; public: void Set(std::string_view sv); TestDocument() = default; // Deleted so TestDocument objects can not be copied. TestDocument(const TestDocument&) = delete; TestDocument(TestDocument&&) = delete; TestDocument &operator=(const TestDocument&) = delete; TestDocument &operator=(TestDocument&&) = delete; virtual ~TestDocument() = default; Sci_Position MaxLine() const noexcept; int SCI_METHOD Version() const override; void SCI_METHOD SetErrorStatus(int status) override; Sci_Position SCI_METHOD Length() const override; void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const override; char SCI_METHOD StyleAt(Sci_Position position) const override; Sci_Position SCI_METHOD LineFromPosition(Sci_Position position) const override; Sci_Position SCI_METHOD LineStart(Sci_Position line) const override; int SCI_METHOD GetLevel(Sci_Position line) const override; int SCI_METHOD SetLevel(Sci_Position line, int level) override; int SCI_METHOD GetLineState(Sci_Position line) const override; int SCI_METHOD SetLineState(Sci_Position line, int state) override; void SCI_METHOD StartStyling(Sci_Position position) override; bool SCI_METHOD SetStyleFor(Sci_Position length, char style) override; bool SCI_METHOD SetStyles(Sci_Position length, const char *styles) override; void SCI_METHOD DecorationSetCurrentIndicator(int indicator) override; void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) override; void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end) override; int SCI_METHOD CodePage() const override; bool SCI_METHOD IsDBCSLeadByte(char ch) const override; const char *SCI_METHOD BufferPointer() override; int SCI_METHOD GetLineIndentation(Sci_Position line) override; Sci_Position SCI_METHOD LineEnd(Sci_Position line) const override; Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const override; int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const override; }; #endif tmpok_q575y/lexilla/test/TestDocument.cxx0000664000175000017500000002065014773064066020327 0ustar gusnangusnan// Lexilla lexer library /** @file TestDocument.cxx ** Lexer testing. **/ // Copyright 2019 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #include #include "ILexer.h" #include "TestDocument.h" namespace { const unsigned char UTF8BytesOfLead[256] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 00 - 0F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10 - 1F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 20 - 2F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 30 - 3F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 40 - 4F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 50 - 5F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 60 - 6F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 70 - 7F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 8F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 90 - 9F 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A0 - AF 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B0 - BF 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0 - CF 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // D0 - DF 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // E0 - EF 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // F0 - FF }; int UnicodeFromUTF8(const unsigned char *us) noexcept { assert(us); switch (UTF8BytesOfLead[us[0]]) { case 1: return us[0]; case 2: return ((us[0] & 0x1F) << 6) + (us[1] & 0x3F); case 3: return ((us[0] & 0xF) << 12) + ((us[1] & 0x3F) << 6) + (us[2] & 0x3F); default: return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F); } } inline constexpr bool UTF8IsTrailByte(unsigned char ch) noexcept { return (ch >= 0x80) && (ch < 0xc0); } constexpr unsigned char TrailByteValue(unsigned char c) { // The top 2 bits are 0b10 to indicate a trail byte. // The lower 6 bits contain the value. return c & 0b0011'1111; } } std::u32string UTF32FromUTF8(std::string_view svu8) { std::u32string ret; for (size_t i = 0; i < svu8.length();) { unsigned char ch = svu8.at(i); const unsigned int byteCount = UTF8BytesOfLead[ch]; unsigned int value = 0; if (i + byteCount > svu8.length()) { // Trying to read past end ret.push_back(ch); break; } i++; switch (byteCount) { case 1: value = ch; break; case 2: value = (ch & 0x1F) << 6; ch = svu8.at(i++); value += TrailByteValue(ch); break; case 3: value = (ch & 0xF) << 12; ch = svu8.at(i++); value += TrailByteValue(ch) << 6; ch = svu8.at(i++); value += TrailByteValue(ch); break; default: value = (ch & 0x7) << 18; ch = svu8.at(i++); value += TrailByteValue(ch) << 12; ch = svu8.at(i++); value += TrailByteValue(ch) << 6; ch = svu8.at(i++); value += TrailByteValue(ch); break; } ret.push_back(value); } return ret; } void TestDocument::Set(std::string_view sv) { text = sv; textStyles.resize(text.size() + 1); lineStarts.clear(); endStyled = 0; lineStarts.push_back(0); for (size_t pos = 0; pos < text.length(); pos++) { if (text.at(pos) == '\n') { lineStarts.push_back(pos + 1); } } if (lineStarts.back() != Length()) { lineStarts.push_back(Length()); } lineStates.resize(lineStarts.size() + 1); lineLevels.resize(lineStarts.size(), 0x400); } #if defined(_MSC_VER) // IDocument interface does not specify noexcept so best to not add it to implementation #pragma warning(disable: 26440) #endif Sci_Position TestDocument::MaxLine() const noexcept { return lineStarts.size() - 1; } int SCI_METHOD TestDocument::Version() const { return Scintilla::dvRelease4; } void SCI_METHOD TestDocument::SetErrorStatus(int) { } Sci_Position SCI_METHOD TestDocument::Length() const { return text.length(); } void SCI_METHOD TestDocument::GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const { text.copy(buffer, lengthRetrieve, position); } char SCI_METHOD TestDocument::StyleAt(Sci_Position position) const { if (position < 0) { return 0; } return textStyles.at(position); } Sci_Position SCI_METHOD TestDocument::LineFromPosition(Sci_Position position) const { if (position >= Length()) { return MaxLine(); } const std::vector::const_iterator it = std::lower_bound(lineStarts.begin(), lineStarts.end(), position); Sci_Position line = it - lineStarts.begin(); if (*it > position) line--; return line; } Sci_Position SCI_METHOD TestDocument::LineStart(Sci_Position line) const { if (line < 0) { return 0; } if (line >= static_cast(lineStarts.size())) { return Length(); } return lineStarts.at(line); } int SCI_METHOD TestDocument::GetLevel(Sci_Position line) const { return lineLevels.at(line); } int SCI_METHOD TestDocument::SetLevel(Sci_Position line, int level) { if (line == static_cast(lineLevels.size())) { return 0x400; } return lineLevels.at(line) = level; } int SCI_METHOD TestDocument::GetLineState(Sci_Position line) const { return lineStates.at(line); } int SCI_METHOD TestDocument::SetLineState(Sci_Position line, int state) { return lineStates.at(line) = state; } void SCI_METHOD TestDocument::StartStyling(Sci_Position position) { endStyled = position; } bool SCI_METHOD TestDocument::SetStyleFor(Sci_Position length, char style) { for (Sci_Position i = 0; i < length; i++) { textStyles.at(endStyled) = style; endStyled++; } return true; } bool SCI_METHOD TestDocument::SetStyles(Sci_Position length, const char *styles) { assert(styles); for (Sci_Position i = 0; i < length; i++) { textStyles.at(endStyled) = styles[i]; endStyled++; } return true; } void SCI_METHOD TestDocument::DecorationSetCurrentIndicator(int) { // Not implemented as no way to read decorations } void SCI_METHOD TestDocument::DecorationFillRange(Sci_Position, int, Sci_Position) { // Not implemented as no way to read decorations } void SCI_METHOD TestDocument::ChangeLexerState(Sci_Position, Sci_Position) { // Not implemented as no watcher to trigger } int SCI_METHOD TestDocument::CodePage() const { // Always UTF-8 for now return 65001; } bool SCI_METHOD TestDocument::IsDBCSLeadByte(char) const { // Always UTF-8 for now return false; } const char *SCI_METHOD TestDocument::BufferPointer() { return text.c_str(); } int SCI_METHOD TestDocument::GetLineIndentation(Sci_Position) { // Never actually called - lexers use Accessor::IndentAmount return 0; } Sci_Position SCI_METHOD TestDocument::LineEnd(Sci_Position line) const { const Sci_Position maxLine = MaxLine(); if (line == maxLine || line == maxLine+1) { return text.length(); } assert(line < maxLine); Sci_Position position = LineStart(line + 1); position--; // Back over CR or LF // When line terminator is CR+LF, may need to go back one more if ((position > LineStart(line)) && (text.at(position - 1) == '\r')) { position--; } return position; } Sci_Position SCI_METHOD TestDocument::GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const { Sci_Position pos = positionStart; if (characterOffset < 0) { while (characterOffset < 0) { if (pos <= 0) { return -1; } unsigned char previousByte = text.at(pos - 1); if (previousByte < 0x80) { pos--; characterOffset++; } else { while ((pos > 1) && UTF8IsTrailByte(previousByte)) { pos--; previousByte = text.at(pos - 1); } pos--; // text[pos] is now a character start characterOffset++; } } return pos; } assert(characterOffset >= 0); // TODO: invalid UTF-8 while (characterOffset > 0) { Sci_Position width = 0; GetCharacterAndWidth(pos, &width); pos += width; characterOffset--; } return pos; } int SCI_METHOD TestDocument::GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const { // TODO: invalid UTF-8 if ((position < 0) || (position >= Length())) { // Return NULs before document start and after document end if (pWidth) { *pWidth = 1; } return '\0'; } const unsigned char leadByte = text.at(position); if (leadByte < 0x80) { if (pWidth) { *pWidth = 1; } return leadByte; } const int widthCharBytes = UTF8BytesOfLead[leadByte]; unsigned char charBytes[] = { leadByte,0,0,0 }; for (int b = 1; b < widthCharBytes; b++) { charBytes[b] = text.at(position + b); } if (pWidth) { *pWidth = widthCharBytes; } return UnicodeFromUTF8(charBytes); } tmpok_q575y/lexilla/test/README0000664000175000017500000001350714773064066016050 0ustar gusnangusnanREADME for testing lexers with lexilla/test. The TestLexers application is run to test the lexing and folding of a set of example files and thus ensure that the lexers are working correctly. Lexers are accessed through the Lexilla shared library which must be built first in the lexilla/src directory. TestLexers works on Windows, Linux, or macOS and requires a C++20 compiler. MSVC 2019.4, GCC 9.0, Clang 9.0, and Apple Clang 11.0 are known to work. MSVC is only available on Windows. GCC and Clang work on Windows and Linux. On macOS, only Apple Clang is available. Lexilla requires some headers from Scintilla to build and expects a directory named "scintilla" containing a copy of Scintilla 5+ to be a peer of the Lexilla top level directory conventionally called "lexilla". To use GCC run lexilla/test/makefile: make test To use Clang run lexilla/test/makefile: make CLANG=1 test On macOS, CLANG is set automatically so this can just be make test To use MSVC: nmake -f testlexers.mak test There is also a project file TestLexers.vcxproj that can be loaded into the Visual C++ IDE. Adding or Changing Tests The lexilla/test/examples directory contains a set of tests located in a tree of subdirectories. Each directory contains example files along with control files called SciTE.properties and expected result files with .styled and .folded suffixes. If an unexpected result occurs then files with the additional suffix .new (that is .styled.new or .folded.new) may be created. Each file in the examples tree that does not have an extension of .properties, .styled, .folded or .new is an example file that will be lexed and folded according to settings found in SciTE.properties. The results of the lex will be compared to the corresponding .styled file and if different the result will be saved to a .styled.new file for checking. So, if x.cxx is the example, its lexed form will be checked against x.cxx.styled and a x.cxx.styled.new file may be created. The .styled.new and .styled files contain the text of the original file along with style number changes in {} like: {5}function{0} {11}first{10}(){0} After checking that the .styled.new file is correct, it can be promoted to .styled and committed to the repository. The results of the fold will be compared to the corresponding .folded file and if different the result will be saved to a .folded.new file for checking. So, if x.cxx is the example, its folded form will be checked against x.cxx.folded and a x.cxx.folded.new file may be created. The folded.new and .folded files contain the text of the original file along with fold information to the left like: 2 400 0 + --[[ coding:UTF-8 0 402 0 | comment ]] There are 4 columns before the file text representing the bits of the fold level: [flags (0xF000), level (0x0FFF), other (0xFFFF0000), picture]. flags: may be 2 for header or 1 for whitespace. level: hexadecimal level number starting at 0x400. 'negative' level numbers like 0x3FF indicate errors in either the folder or in the input file, such as a C file that starts with #endif. other: can be used as the folder wants. Often used to hold the level of the next line. picture: gives a rough idea of the fold structure: '|' for level greater than 0x400, '+' for header, ' ' otherwise. After checking that the .folded.new file is correct, it can be promoted to .folded and committed to the repository. An interactive file comparison program like WinMerge (https://winmerge.org/) on Windows or meld (https://meldmerge.org/) on Linux can help examine differences between the .styled and .styled.new files or .folded and .folded.new files. On Windows, the scripts/PromoteNew.bat script can be run to promote all .new result files to their base names without .new. Styling and folding tests are first performed on the file as a whole, then the file is lexed and folded line-by-line. If there are differences between the whole file and line-by-line then a message with 'per-line is different' for styling or 'per-line has different folds' will be printed. Problems with line-by-line processing are often caused by local variables in the lexer or folder that are incorrectly initialised. Sometimes extra state can be inferred, but it may have to be stored between runs (possibly with SetLineState) or the code may have to backtrack to a previous safe line - often something like a line that starts with a character in the default style. The SciTE.properties file is similar to properties files used for SciTE but are simpler. The lexer to be run is defined with a lexer.{filepatterns} statement like: lexer.*.d=d Keywords may be defined with keywords settings like: keywords.*.cxx;*.c=int char keywords2.*.cxx=open Substyles and substyle identifiers may be defined with settings like: substyles.cpp.11=1 substylewords.11.1.*.cxx=map string vector Other settings are treated as lexer or folder properties and forwarded to the lexer/folder: lexer.cpp.track.preprocessor=1 fold=1 It is often necessary to set 'fold' in SciTE.properties to cause folding. Properties can be set for a particular file with an "if $(=" or "match" expression like so: if $(= $(FileNameExt);HeaderEOLFill_1.md) lexer.markdown.header.eolfill=1 match Header*1.md lexer.markdown.header.eolfill=1 More complex tests with additional configurations of keywords or properties can be performed by creating another subdirectory with the different settings in a new SciTE.properties. There is some support for running benchmarks on lexers and folders. The properties testlexers.repeat.lex and testlexers.repeat.fold specify the number of times example documents are lexed or folded. Set to a large number like testlexers.repeat.lex=10000 then run with a profiler. A list of styles used in a lex can be displayed with testlexers.list.styles=1. tmpok_q575y/lexilla/test/testlexers.mak0000664000175000017500000000147514773064066020065 0ustar gusnangusnan# Build the lexers test with Microsoft Visual C++ using nmake # Tested with Visual C++ 2022 DEL = del /q EXE = TestLexers.exe INCLUDEDIRS = -I ../../scintilla/include -I ../include -I ../access !IFDEF LEXILLA_STATIC STATIC_FLAG = -D LEXILLA_STATIC LIBS = ../bin/liblexilla.lib !ENDIF !IFDEF DEBUG DEBUG_OPTIONS = -Zi -DEBUG -Od -MTd -DDEBUG $(STATIC_FLAG) !ELSE DEBUG_OPTIONS = -O2 -MT -DNDEBUG $(STATIC_FLAG) -GL !ENDIF CXXFLAGS = /EHsc /std:c++20 $(DEBUG_OPTIONS) $(INCLUDEDIRS) OBJS = TestLexers.obj TestDocument.obj LexillaAccess.obj all: $(EXE) test: $(EXE) $(EXE) clean: $(DEL) *.o *.obj *.exe $(EXE): $(OBJS) $(LIBS) $(CXX) $(CXXFLAGS) $(LIBS) /Fe$@ $** .cxx.obj:: $(CXX) $(CXXFLAGS) -c $< {..\access}.cxx.obj:: $(CXX) $(CXXFLAGS) -c $< TestLexers.obj: $*.cxx TestDocument.h TestDocument.obj: $*.cxx $*.h tmpok_q575y/lexilla/test/TestLexers.cxx0000664000175000017500000007460314773064066020022 0ustar gusnangusnan// Lexilla lexer library /** @file TestLexers.cxx ** Test lexers through Lexilla. **/ // Copyright 2019 by Neil Hodgson // The License.txt file describes the conditions under which this software may be distributed. #include #include #include #include #include #include #include #include #include #include #include #include #include "ILexer.h" #include "Lexilla.h" #include "LexillaAccess.h" #include "TestDocument.h" namespace { constexpr char MakeLowerCase(char c) noexcept { if (c >= 'A' && c <= 'Z') { return c - 'A' + 'a'; } else { return c; } } [[maybe_unused]] void LowerCaseAZ(std::string &s) { std::transform(s.begin(), s.end(), s.begin(), MakeLowerCase); } int IntFromString(std::u32string_view s) noexcept { if (s.empty()) { return 0; } const bool negate = s.front() == '-'; if (negate) { s.remove_prefix(1); } int value = 0; while (!s.empty()) { value = value * 10 + s.front() - '0'; s.remove_prefix(1); } return negate ? -value : value; } bool PatternMatch(std::u32string_view pattern, std::u32string_view text) noexcept { if (pattern == text) { return true; } else if (pattern.empty()) { return false; } else if (pattern.front() == '\\') { pattern.remove_prefix(1); if (pattern.empty()) { // Escape with nothing being escaped return false; } if (text.empty()) { return false; } if (pattern.front() == text.front()) { pattern.remove_prefix(1); text.remove_prefix(1); return PatternMatch(pattern, text); } return false; } else if (pattern.front() == '*') { pattern.remove_prefix(1); if (!pattern.empty() && pattern.front() == '*') { pattern.remove_prefix(1); // "**" matches anything including "/" while (!text.empty()) { if (PatternMatch(pattern, text)) { return true; } text.remove_prefix(1); } } else { while (!text.empty()) { if (PatternMatch(pattern, text)) { return true; } if (text.front() == '/') { // "/" not matched by single "*" return false; } text.remove_prefix(1); } } assert(text.empty()); // Consumed whole text with wildcard so match if pattern consumed return pattern.empty(); } else if (text.empty()) { return false; } else if (pattern.front() == '?') { if (text.front() == '/') { return false; } pattern.remove_prefix(1); text.remove_prefix(1); return PatternMatch(pattern, text); } else if (pattern.front() == '[') { pattern.remove_prefix(1); if (pattern.empty()) { return false; } const bool positive = pattern.front() != '!'; if (!positive) { pattern.remove_prefix(1); if (pattern.empty()) { return false; } } bool inSet = false; if (!pattern.empty() && pattern.front() == ']') { // First is allowed to be ']' if (pattern.front() == text.front()) { inSet = true; } pattern.remove_prefix(1); } char32_t start = 0; while (!pattern.empty() && pattern.front() != ']') { if (pattern.front() == '-') { pattern.remove_prefix(1); if (!pattern.empty()) { const char32_t end = pattern.front(); if ((text.front() >= start) && (text.front() <= end)) { inSet = true; } } } else if (pattern.front() == text.front()) { inSet = true; } if (!pattern.empty()) { start = pattern.front(); pattern.remove_prefix(1); } } if (!pattern.empty()) { pattern.remove_prefix(1); } if (inSet != positive) { return false; } text.remove_prefix(1); return PatternMatch(pattern, text); } else if (pattern.front() == '{') { if (pattern.length() < 2) { return false; } const size_t endParen = pattern.find('}'); if (endParen == std::u32string_view::npos) { // Malformed {x} pattern return false; } std::u32string_view parenExpression = pattern.substr(1, endParen - 1); bool inSet = false; const size_t dotdot = parenExpression.find(U".."); if (dotdot != std::u32string_view::npos) { // Numeric range: {10..20} const std::u32string_view firstRange = parenExpression.substr(0, dotdot); const std::u32string_view lastRange = parenExpression.substr(dotdot+2); if (firstRange.empty() || lastRange.empty()) { // Malformed {s..e} range pattern return false; } const size_t endInteger = text.find_last_of(U"-0123456789"); if (endInteger == std::u32string_view::npos) { // No integer in text return false; } const std::u32string_view intPart = text.substr(0, endInteger+1); const int first = IntFromString(firstRange); const int last = IntFromString(lastRange); const int value = IntFromString(intPart); if ((value >= first) && (value <= last)) { inSet = true; text.remove_prefix(intPart.length()); } } else { // Alternates: {a,b,cd} size_t comma = parenExpression.find(','); for (;;) { const bool finalAlt = comma == std::u32string_view::npos; const std::u32string_view oneAlt = finalAlt ? parenExpression : parenExpression.substr(0, comma); if (oneAlt == text.substr(0, oneAlt.length())) { // match inSet = true; text.remove_prefix(oneAlt.length()); break; } if (finalAlt) { break; } parenExpression.remove_prefix(oneAlt.length() + 1); comma = parenExpression.find(','); } } if (!inSet) { return false; } pattern.remove_prefix(endParen + 1); return PatternMatch(pattern, text); } else if (pattern.front() == text.front()) { pattern.remove_prefix(1); text.remove_prefix(1); return PatternMatch(pattern, text); } return false; } bool PathMatch(std::string pattern, std::string relPath) { #if defined(_WIN32) // Convert Windows path separators to Unix std::replace(relPath.begin(), relPath.end(), '\\', '/'); #endif #if defined(_WIN32) || defined(__APPLE__) // Case-insensitive, only does ASCII but fine for test example files LowerCaseAZ(pattern); LowerCaseAZ(relPath); #endif const std::u32string patternU32 = UTF32FromUTF8(pattern); const std::u32string relPathU32 = UTF32FromUTF8(relPath); if (PatternMatch(patternU32, relPathU32)) { return true; } const size_t lastSlash = relPathU32.rfind('/'); if (lastSlash == std::string::npos) { return false; } // Match against just filename const std::u32string fileNameU32 = relPathU32.substr(lastSlash+1); return PatternMatch(patternU32, fileNameU32); } constexpr std::string_view suffixStyled = ".styled"; constexpr std::string_view suffixFolded = ".folded"; constexpr std::string_view lexerPrefix = "lexer.*"; constexpr std::string_view prefixIf = "if "; constexpr std::string_view prefixMatch = "match "; constexpr std::string_view prefixEqual = "= "; constexpr std::string_view prefixComment = "#"; std::string ReadFile(std::filesystem::path path) { std::ifstream ifs(path, std::ios::binary); std::string content((std::istreambuf_iterator(ifs)), (std::istreambuf_iterator())); return content; } std::string MarkedDocument(const Scintilla::IDocument *pdoc) { assert(pdoc); std::ostringstream os(std::ios::binary); char prevStyle = -1; for (Sci_Position pos = 0; pos < pdoc->Length(); pos++) { const char styleNow = pdoc->StyleAt(pos); if (styleNow != prevStyle) { const unsigned char uStyleNow = styleNow; const unsigned int uiStyleNow = uStyleNow; os << "{" << uiStyleNow << "}"; prevStyle = styleNow; } char ch = '\0'; pdoc->GetCharRange(&ch, pos, 1); os << ch; } return os.str(); } void PrintLevel(std::ostringstream &os, int level) { const int levelNow = level & 0xFFF; const int levelNext = level >> 16; const int levelFlags = (level >> 12) & 0xF; char foldSymbol = ' '; if (level & 0x2000) foldSymbol = '+'; else if (levelNow > 0x400) foldSymbol = '|'; os << std::hex << " " << levelFlags << " " << std::setw(3) << levelNow << " " << std::setw(3) << levelNext << " " << foldSymbol << " "; } std::string FoldedDocument(const Scintilla::IDocument *pdoc) { assert(pdoc); std::ostringstream os(std::ios::binary); Sci_Position linePrev = -1; char ch = '\0'; for (Sci_Position pos = 0; pos < pdoc->Length(); pos++) { const Sci_Position lineNow = pdoc->LineFromPosition(pos); if (linePrev < lineNow) { PrintLevel(os, pdoc->GetLevel(lineNow)); linePrev = lineNow; } pdoc->GetCharRange(&ch, pos, 1); os << ch; } if (ch == '\n') { // Extra empty line PrintLevel(os, pdoc->GetLevel(linePrev + 1)); } return os.str(); } std::pair MarkedAndFoldedDocument(const Scintilla::IDocument *pdoc) { return { MarkedDocument(pdoc), FoldedDocument(pdoc) }; } std::vector StringSplit(const std::string_view &text, int separator) { std::vector vs(text.empty() ? 0 : 1); for (std::string_view::const_iterator it = text.begin(); it != text.end(); ++it) { if (*it == separator) { vs.push_back(std::string()); } else { vs.back() += *it; } } return vs; } constexpr bool IsSpaceOrTab(char ch) noexcept { return (ch == ' ') || (ch == '\t'); } void PrintRanges(const std::vector &v) { std::cout << " "; std::optional startRange; for (size_t style = 0; style <= v.size(); style++) { // Goes one past size so that final range is closed if ((style < v.size()) && v.at(style)) { if (!startRange) { startRange = style; } } else if (startRange) { const size_t endRange = style - 1; std::cout << *startRange; if (*startRange != endRange) { std::cout << "-" << endRange; } std::cout << " "; startRange.reset(); } } std::cout << "\n"; } class PropertyMap { std::string Evaluate(std::string_view text) { if (text.find(' ') != std::string_view::npos) { if (text.starts_with(prefixEqual)) { const std::string_view sExpressions = text.substr(prefixEqual.length()); std::vector parts = StringSplit(sExpressions, ';'); if (parts.size() > 1) { for (size_t part = 1; part < parts.size(); part++) { if (parts.at(part) != parts.at(0)) { return "0"; } } return "1"; } } return {}; } else { std::optional value = GetProperty(text); if (value) { return *value; } return {}; } } std::string Expand(std::string withVars) { constexpr size_t maxVars = 100; size_t varStart = withVars.rfind("$("); for (size_t count = 0; (count < maxVars) && (varStart != std::string::npos); count++) { const size_t varEnd = withVars.find(')', varStart + 2); if (varEnd == std::string::npos) { break; } const std::string_view whole = withVars; const std::string_view var = whole.substr(varStart + 2, varEnd - (varStart + 2)); const std::string val = Evaluate(var); withVars.erase(varStart, varEnd - varStart + 1); withVars.insert(varStart, val); varStart = withVars.rfind("$("); } return withVars; } std::vector GetFilePatterns(const std::string &key) const { std::vector exts; // Malformed patterns are skipped if we require the whole prefix here; // a fuzzy search lets us collect and report them const size_t patternStart = key.find('*'); if (patternStart == std::string::npos) return exts; const std::string patterns = key.substr(patternStart); for (const std::string &pat : StringSplit(patterns, ';')) { // Only accept patterns in the form *.xyz if (pat.starts_with("*.") && pat.length() > 2) { exts.push_back(pat.substr(1)); } else { std::cout << "\n" << "Ignoring bad file pattern '" << pat << "' in list " << patterns << "\n"; } } return exts; } bool ProcessLine(std::string_view text, bool ifIsTrue) { // If clause ends with first non-indented line if (!ifIsTrue && (text.empty() || IsSpaceOrTab(text.at(0)))) { return false; } ifIsTrue = true; if (text.starts_with(prefixIf)) { const std::string value = Expand(std::string(text.substr(prefixIf.length()))); if (value == "0" || value == "") { ifIsTrue = false; } } else if (text.starts_with(prefixMatch)) { std::optional fileNameExt = GetProperty("FileNameExt"); if (fileNameExt) { std::string pattern(text.substr(prefixMatch.length())); // Remove trailing white space while (!pattern.empty() && IsSpaceOrTab(pattern.back())) { pattern.pop_back(); } ifIsTrue = PathMatch(pattern, *fileNameExt); } else { ifIsTrue = false; } } else { while (!text.empty() && IsSpaceOrTab(text.at(0))) { text.remove_prefix(1); } if (text.starts_with(prefixComment)) { return ifIsTrue; } const size_t positionEquals = text.find("="); if (positionEquals != std::string::npos) { const std::string key(text.substr(0, positionEquals)); const std::string_view value = text.substr(positionEquals + 1); properties[key] = value; } } return ifIsTrue; } public: using PropMap = std::map; PropMap properties; void ReadFromFile(std::filesystem::path path) { bool ifIsTrue = true; std::ifstream ifs(path); std::string line; std::string logicalLine; while (std::getline(ifs, line)) { if (line.ends_with("\r")) { // Accidentally have \r\n line ends on Unix system line.pop_back(); } logicalLine += line; if (logicalLine.ends_with("\\")) { logicalLine.pop_back(); } else { ifIsTrue = ProcessLine(logicalLine, ifIsTrue); logicalLine.clear(); } } } std::optional GetProperty(std::string_view key) const { const PropMap::const_iterator prop = properties.find(std::string(key)); if (prop == properties.end()) return std::nullopt; else return prop->second; } std::optional GetPropertyForFile(std::string_view keyPrefix, std::string_view fileName) const { for (auto const &[key, val] : properties) { if (key.starts_with(keyPrefix)) { const std::string keySuffix = key.substr(keyPrefix.length()); if (fileName.ends_with(keySuffix)) { return val; } else if (key.find(';') != std::string::npos) { // It may be the case that a suite of test files with various extensions are // meant to share a common configuration, so try to find a matching // extension in a delimited list, e.g., lexer.*.html;*.php;*.asp=hypertext for (const std::string &ext : GetFilePatterns(key)) { if (fileName.ends_with(ext)) { return val; } } } } } return std::nullopt; } std::optional GetPropertyValue(std::string_view key) const { std::optional value = GetProperty(key); try { if (value) return std::stoi(value->c_str()); } catch (std::invalid_argument &) { // Just return empty } return {}; } }; size_t FirstLineDifferent(std::string_view a, std::string_view b) { size_t i = 0; while (i < std::min(a.size(), b.size()) && a.at(i) == b.at(i)) { i++; } return std::count(a.begin(), a.begin() + i, '\n'); } bool CheckSame(std::string_view augmentedText, std::string_view augmentedTextNew, std::string_view item, std::string_view suffix, const std::filesystem::path &path) { if (augmentedTextNew == augmentedText) { return true; } const size_t lineNumber = FirstLineDifferent(augmentedText, augmentedTextNew) + 1; std::cout << "\n" << path.string() << ":" << lineNumber << ":"; const std::string differenceType = augmentedText.empty() ? "new" : "different"; std::cout << " has " << differenceType << " " << item << "\n\n"; std::filesystem::path pathNew = path; pathNew += suffix; pathNew += ".new"; std::ofstream ofs(pathNew, std::ios::binary); ofs << augmentedTextNew; return false; } int Substitute(std::string &s, const std::string &sFind, const std::string &sReplace) { int c = 0; const size_t lenFind = sFind.size(); const size_t lenReplace = sReplace.size(); size_t posFound = s.find(sFind); while (posFound != std::string::npos) { s.replace(posFound, lenFind, sReplace); posFound = s.find(sFind, posFound + lenReplace); c++; } return c; } int WindowsToUnix(std::string &s) { return Substitute(s, "\r\n", "\n"); } int UnixToWindows(std::string &s) { return Substitute(s, "\n", "\r\n"); } const std::string BOM = "\xEF\xBB\xBF"; void StyleLineByLine(TestDocument &doc, Scintilla::ILexer5 *plex) { assert(plex); Scintilla::IDocument *pdoc = &doc; const Sci_Position lines = doc.LineFromPosition(doc.Length()); Sci_Position startLine = 0; for (Sci_Position line = 0; line <= lines; line++) { const Sci_Position endLine = doc.LineStart(line + 1); int styleStart = 0; if (startLine > 0) styleStart = doc.StyleAt(startLine - 1); plex->Lex(startLine, endLine - startLine, styleStart, pdoc); plex->Fold(startLine, endLine - startLine, styleStart, pdoc); startLine = endLine; } } bool TestCRLF(std::filesystem::path path, const std::string s, Scintilla::ILexer5 *plex, bool disablePerLineTests) { assert(plex); bool success = true; // Convert all line ends to \r\n to check if styles change between \r and \n which makes // it difficult to test on different platforms when files may have line ends changed. std::string text = s; WindowsToUnix(text); const bool originalIsUnix = text == s; std::string textUnix = text; UnixToWindows(text); TestDocument doc; doc.Set(text); Scintilla::IDocument *pdoc = &doc; assert(pdoc); plex->Lex(0, pdoc->Length(), 0, pdoc); plex->Fold(0, pdoc->Length(), 0, pdoc); const auto [styledText, foldedText] = MarkedAndFoldedDocument(pdoc); int prevStyle = -1; Sci_Position line = 1; for (Sci_Position pos = 0; pos < pdoc->Length(); pos++) { const int styleNow = pdoc->StyleAt(pos); char ch = '\0'; pdoc->GetCharRange(&ch, pos, 1); if (ch == '\n') { if (styleNow != prevStyle) { std::cout << path.string() << ":" << line << ":" << " different styles between \\r and \\n at " << pos << ": " << prevStyle << ", " << styleNow << "\n"; success = false; } line++; } prevStyle = styleNow; } // Lex and fold with \n line ends then check result is same TestDocument docUnix; docUnix.Set(textUnix); Scintilla::IDocument *pdocUnix = &docUnix; assert(pdocUnix); plex->Lex(0, pdocUnix->Length(), 0, pdocUnix); plex->Fold(0, pdocUnix->Length(), 0, pdocUnix); auto [styledTextUnix, foldedTextUnix] = MarkedAndFoldedDocument(pdocUnix); // Convert results from \n to \r\n run UnixToWindows(styledTextUnix); UnixToWindows(foldedTextUnix); if (styledText != styledTextUnix) { std::cout << "\n" << path.string() << ":1: has different styles with \\n versus \\r\\n line ends\n\n"; success = false; } if (foldedText != foldedTextUnix) { std::cout << "\n" << path.string() << ":1: has different folds with \\n versus \\r\\n line ends\n\n"; success = false; } // Test line by line lexing/folding with Unix \n line ends if (!disablePerLineTests && !originalIsUnix) { StyleLineByLine(docUnix, plex); auto [styledTextNewPerLine, foldedTextNewPerLine] = MarkedAndFoldedDocument(pdocUnix); // Convert results from \n to \r\n run UnixToWindows(styledTextNewPerLine); UnixToWindows(foldedTextNewPerLine); if (!CheckSame(styledTextUnix, styledTextNewPerLine, "per-line styles \\n", suffixStyled, path)) { success = false; } if (!CheckSame(foldedTextUnix, foldedTextNewPerLine, "per-line folds \\n", suffixFolded, path)) { success = false; } } plex->Release(); return success; } void TestILexer(Scintilla::ILexer5 *plex) { assert(plex); // Test each method of the ILexer interface. // Mostly ensures there are no crashes when calling methods. // Some methods are tested later (Release, Lex, Fold). // PrivateCall performs arbitrary actions so is not safe to call. [[maybe_unused]] const int version = plex->Version(); assert(version == Scintilla::lvRelease5); [[maybe_unused]] const char *language = plex->GetName(); assert(language); [[maybe_unused]] const int ident = plex->GetIdentifier(); assert(ident >= 0); [[maybe_unused]] const char *propertyNames = plex->PropertyNames(); assert(propertyNames); [[maybe_unused]] const int propertyType = plex->PropertyType("unknown"); assert(propertyType >= 0 && propertyType <= 2); [[maybe_unused]] const char *propertyDescription = plex->DescribeProperty("unknown"); assert(propertyDescription); [[maybe_unused]] const Sci_Position invalidation = plex->PropertySet("unknown", "unknown"); assert(invalidation == 0 || invalidation == -1); [[maybe_unused]] const char *wordListDescription = plex->DescribeWordListSets(); assert(wordListDescription); [[maybe_unused]] const Sci_Position invalidationWordList = plex->WordListSet(9, "unknown"); assert(invalidationWordList == 0 || invalidationWordList == -1); [[maybe_unused]] const int lineEndTypes = plex->LineEndTypesSupported(); assert(lineEndTypes == 0 || lineEndTypes == 1); if (std::string_view bases = plex->GetSubStyleBases(); !bases.empty()) { // Allocate a substyle for each possible style while (!bases.empty()) { constexpr int newStyles = 3; const int base = bases.front(); const int baseStyle = plex->AllocateSubStyles(base, newStyles); [[maybe_unused]] const int styleBack = plex->StyleFromSubStyle(baseStyle); assert(styleBack == base); plex->SetIdentifiers(baseStyle, "int nullptr"); [[maybe_unused]] const int start = plex->SubStylesStart(base); assert(start == baseStyle); [[maybe_unused]] const int len = plex->SubStylesLength(base); assert(len == newStyles); bases.remove_prefix(1); } plex->FreeSubStyles(); } [[maybe_unused]] const int primary = plex->PrimaryStyleFromStyle(2); assert(primary == 2); [[maybe_unused]] const int distance = plex->DistanceToSecondaryStyles(); assert(distance >= 0); // Just see if crashes - nullptr is valid return to indicate not present. [[maybe_unused]] const char *propertyUnknownValue = plex->PropertyGet("unknown"); const int styles = plex->NamedStyles(); for (int style = 0; style < styles; style++) { [[maybe_unused]] const char *name = plex->NameOfStyle(style); assert(name); [[maybe_unused]] const char *tags = plex->TagsOfStyle(style); assert(tags); [[maybe_unused]] const char *description = plex->DescriptionOfStyle(style); assert(description); } } bool SetProperties(Scintilla::ILexer5 *plex, const std::string &language, const PropertyMap &propertyMap, std::filesystem::path path) { assert(plex); const std::string fileName = path.filename().string(); if (std::string_view bases = plex->GetSubStyleBases(); !bases.empty()) { // Allocate a substyle for each possible style while (!bases.empty()) { const int baseStyle = bases.front(); // substyles.cpp.11=2 const std::string base = std::to_string(baseStyle); const std::string substylesForBase = "substyles." + language + "." + base; std::optional substylesN = propertyMap.GetProperty(substylesForBase); if (substylesN) { const int substyles = atoi(substylesN->c_str()); const int baseStyleNum = plex->AllocateSubStyles(baseStyle, substyles); // substylewords.11.1.$(file.patterns.cpp)=std map string vector for (int kw = 0; kw < substyles; kw++) { const std::string substyleWords = "substylewords." + base + "." + std::to_string(kw + 1) + ".*"; const std::optional keywordN = propertyMap.GetPropertyForFile(substyleWords, fileName); if (keywordN) { plex->SetIdentifiers(baseStyleNum + kw, keywordN->c_str()); } } } bases.remove_prefix(1); } } // Set keywords, keywords2, ... keywords9, for this file for (int kw = 0; kw < 10; kw++) { std::string kwChoice("keywords"); if (kw > 0) { kwChoice.push_back(static_cast('1' + kw)); } kwChoice.append(".*"); std::optional keywordN = propertyMap.GetPropertyForFile(kwChoice, fileName); if (keywordN) { // New lexer object has all word lists empty so check null effect from setting empty const Sci_Position changedEmpty = plex->WordListSet(kw, ""); if (changedEmpty != -1) { std::cout << path.string() << ":1: does not return -1 for null WordListSet(" << kw << ")\n"; return false; } const Sci_Position changedAt = plex->WordListSet(kw, keywordN->c_str()); if (keywordN->empty()) { if (changedAt != -1) { std::cout << path.string() << ":1: does not return -1 for WordListSet(" << kw << ") to same empty" << "\n"; return false; } } else { if (changedAt == -1) { std::cout << path.string() << ":1: returns -1 for WordListSet(" << kw << ")\n"; return false; } } } } // Set parameters of lexer for (auto const &[key, val] : propertyMap.properties) { if (key.starts_with("lexer.*")) { // Ignore as processed earlier } else if (key.starts_with("keywords")) { // Ignore as processed earlier } else if (key.starts_with("substyle")) { // Ignore as processed earlier } else { plex->PropertySet(key.c_str(), val.c_str()); } } return true; } bool TestFile(const std::filesystem::path &path, const PropertyMap &propertyMap) { // Find and create correct lexer std::optional language = propertyMap.GetPropertyForFile(lexerPrefix, path.filename().string()); if (!language) { std::cout << "\n" << path.string() << ":1: has no language\n\n"; return false; } Scintilla::ILexer5 *plex = Lexilla::MakeLexer(*language); if (!plex) { std::cout << "\n" << path.string() << ":1: has no lexer for " << *language << "\n\n"; return false; } TestILexer(plex); if (!SetProperties(plex, *language, propertyMap, path)) { return false; } std::string text = ReadFile(path); if (text.starts_with(BOM)) { text.erase(0, BOM.length()); } std::filesystem::path pathStyled = path; pathStyled += suffixStyled; const std::string styledText = ReadFile(pathStyled); std::filesystem::path pathFolded = path; pathFolded += suffixFolded; const std::string foldedText = ReadFile(pathFolded); const int repeatLex = propertyMap.GetPropertyValue("testlexers.repeat.lex").value_or(1); const int repeatFold = propertyMap.GetPropertyValue("testlexers.repeat.fold").value_or(1); TestDocument doc; doc.Set(text); Scintilla::IDocument *pdoc = &doc; assert(pdoc); for (int i = 0; i < repeatLex; i++) { plex->Lex(0, pdoc->Length(), 0, pdoc); } for (int i = 0; i < repeatFold; i++) { plex->Fold(0, pdoc->Length(), 0, pdoc); } bool success = true; const auto [styledTextNew, foldedTextNew] = MarkedAndFoldedDocument(pdoc); if (!CheckSame(styledText, styledTextNew, "styles", suffixStyled, path)) { success = false; } if (!CheckSame(foldedText, foldedTextNew, "folds", suffixFolded, path)) { success = false; } if (propertyMap.GetPropertyValue("testlexers.list.styles").value_or(0)) { std::vector used(0x100); for (Sci_Position pos = 0; pos < pdoc->Length(); pos++) { const unsigned char uchStyle = pdoc->StyleAt(pos); const unsigned style = uchStyle; used.at(style) = true; } PrintRanges(used); } const std::optional perLineDisable = propertyMap.GetPropertyValue("testlexers.per.line.disable"); const bool disablePerLineTests = perLineDisable.value_or(false); plex->Release(); // Test line by line lexing/folding if (success && !disablePerLineTests) { TestDocument docPerLine; docPerLine.Set(text); Scintilla::ILexer5 *plexPerLine = Lexilla::MakeLexer(*language); if (!SetProperties(plexPerLine, *language, propertyMap, path)) { return false; } StyleLineByLine(docPerLine, plexPerLine); const auto [styledTextNewPerLine, foldedTextNewPerLine] = MarkedAndFoldedDocument(&docPerLine); success = success && CheckSame(styledText, styledTextNewPerLine, "per-line styles", suffixStyled, path); success = success && CheckSame(foldedText, foldedTextNewPerLine, "per-line folds", suffixFolded, path); } if (success) { Scintilla::ILexer5 *plexCRLF = Lexilla::MakeLexer(*language); SetProperties(plexCRLF, *language, propertyMap, path.filename().string()); success = TestCRLF(path, text, plexCRLF, disablePerLineTests); } return success; } bool TestDirectory(std::filesystem::path directory, std::filesystem::path basePath) { bool success = true; for (auto &p : std::filesystem::directory_iterator(directory)) { if (!p.is_directory()) { const std::string extension = p.path().extension().string(); if (extension != ".properties" && extension != suffixStyled && extension != ".new" && extension != suffixFolded) { const std::filesystem::path relativePath = p.path().lexically_relative(basePath); std::cout << "Lexing " << relativePath.string() << '\n'; PropertyMap properties; properties.properties["FileNameExt"] = p.path().filename().string(); properties.ReadFromFile(directory / "SciTE.properties"); if (!TestFile(p, properties)) { success = false; } } } } return success; } bool AccessLexilla(std::filesystem::path basePath) { if (!std::filesystem::exists(basePath)) { std::cout << "No examples at " << basePath.string() << "\n"; return false; } bool success = true; for (auto &p : std::filesystem::recursive_directory_iterator(basePath)) { if (p.is_directory()) { //std::cout << p.path().string() << '\n'; if (!TestDirectory(p, basePath)) { success = false; } } } return success; } std::filesystem::path FindLexillaDirectory(std::filesystem::path startDirectory) { // Search up from startDirectory for a directory named "lexilla" or containing a "bin" subdirectory std::filesystem::path directory = startDirectory; while (!directory.empty()) { //std::cout << "Searching " << directory.string() << "\n"; const std::filesystem::path parent = directory.parent_path(); const std::filesystem::path localLexilla = directory / "lexilla"; const std::filesystem::directory_entry entry(localLexilla); if (entry.is_directory()) { std::cout << "Found Lexilla at " << entry.path().string() << "\n"; return localLexilla; } const std::filesystem::path localBin = directory / "bin"; const std::filesystem::directory_entry entryBin(localBin); if (entryBin.is_directory()) { std::cout << "Found Lexilla at " << directory.string() << "\n"; return directory; } if (parent == directory) { std::cout << "Reached root at " << directory.string() << "\n"; return std::filesystem::path(); } directory = parent; } return std::filesystem::path(); } } int main(int argc, char **argv) { bool success = false; const std::filesystem::path baseDirectory = FindLexillaDirectory(std::filesystem::current_path()); if (!baseDirectory.empty()) { #if !defined(LEXILLA_STATIC) const std::filesystem::path sharedLibrary = baseDirectory / "bin" / LEXILLA_LIB; if (!Lexilla::Load(sharedLibrary.string())) { std::cout << "Failed to load " << sharedLibrary << "\n"; return 1; // Indicate failure } #endif std::filesystem::path examplesDirectory = baseDirectory / "test" / "examples"; for (int i = 1; i < argc; i++) { if (argv[i][0] != '-') { examplesDirectory = argv[i]; } } success = AccessLexilla(examplesDirectory); } return success ? 0 : 1; } tmpok_q575y/lexilla/test/unit/0000775000175000017500000000000014773064066016141 5ustar gusnangusnantmpok_q575y/lexilla/test/unit/Sci.natvis0000664000175000017500000000264414773064066020113 0ustar gusnangusnan {{size = {lengthBody}}} lengthBody part1Length gapLength lengthBody body[($i<part1Length)?$i:$i+gapLength] {{size = {body->lengthBody}}} body->lengthBody body->body[($i<body->part1Length)?$i:$i+body->gapLength]+($i>stepPartition?stepLength:0) _Mypair._Myval2 empty unique_ptr {*_Mypair._Myval2} _Mypair._Myval2 _Mypair tmpok_q575y/lexilla/test/unit/makefile0000664000175000017500000000277214773064066017651 0ustar gusnangusnan# Build all the unit tests using GNU make and either g++ or clang # Should be run using mingw32-make on Windows, not nmake # On Windows g++ is used, on macOS clang, and on Linux G++ is used by default # but clang can be used by defining CLANG when invoking make # clang works only with libc++, not libstdc++ # Tested with clang 9 and g++ 9 CXXSTD=c++17 ifndef windir ifeq ($(shell uname),Darwin) # On macOS always use clang as g++ is old version CLANG = 1 USELIBCPP = 1 endif endif CXXFLAGS += --std=$(CXXSTD) ifdef CLANG CXX = clang++ ifdef USELIBCPP # macOS, use libc++ but don't have sanitizers CXXFLAGS += --stdlib=libc++ else # Linux, have sanitizers SANITIZE = -fsanitize=address,undefined CXXFLAGS += $(SANITIZE) endif else CXX = g++ endif ifdef windir DEL = del /q EXE = unitTest.exe else DEL = rm -f EXE = unitTest endif vpath %.cxx ../../lexlib INCLUDEDIRS = -I ../../include -I../../lexlib -I../../../scintilla/include CPPFLAGS += $(INCLUDEDIRS) CXXFLAGS += -Wall -Wextra # Files in this directory containing tests TESTSRC=$(wildcard test*.cxx) TESTOBJ=$(TESTSRC:.cxx=.o) # Files being tested from lexilla/lexlib directory TESTEDOBJ=\ Accessor.o \ CharacterSet.o \ InList.o \ LexerBase.o \ LexerModule.o \ LexerSimple.o \ PropSetSimple.o \ WordList.o TESTS=$(EXE) all: $(TESTS) test: $(TESTS) ./$(EXE) clean: $(DEL) $(TESTS) *.o *.obj *.exe %.o: %.cxx $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ $(EXE): unitTest.o $(TESTOBJ) $(TESTEDOBJ) $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LINKFLAGS) $^ -o $@ tmpok_q575y/lexilla/test/unit/testOptionSet.cxx0000664000175000017500000000733214773064066021516 0ustar gusnangusnan/** @file testOptionSet.cxx ** Unit Tests for Lexilla internal data structures ** Tests OptionSet. **/ #include #include #include #include #include "Scintilla.h" #include "OptionSet.h" #include "catch.hpp" using namespace Lexilla; // Test OptionSet. namespace { // Simple example options structure with each type: string, bool, int struct Options { std::string so; bool bo = false; int io = 0; }; const char *const denseWordLists[] = { "Keywords 1", "Keywords 2", "Keywords 3", "Keywords 4", nullptr, }; const char *const sparseWordLists[] = { "", "", "Keywords 1", "", "Keywords 2", nullptr, }; } using Catch::Matchers::Equals; TEST_CASE("OptionSet") { OptionSet os; Options options; SECTION("IsEmptyInitially") { REQUIRE_THAT(os.PropertyNames(), Equals("")); } SECTION("MissingOption") { // Check for not present option REQUIRE_FALSE(os.PropertyGet("missing")); REQUIRE(SC_TYPE_BOOLEAN == os.PropertyType("missing")); REQUIRE_FALSE(os.PropertySet(&options, "missing", "1")); } SECTION("Define") { os.DefineProperty("string.option", &Options::so, "StringOption"); REQUIRE_THAT(os.PropertyGet("string.option"), Equals("")); REQUIRE(SC_TYPE_STRING == os.PropertyType("string.option")); REQUIRE_THAT(os.DescribeProperty("string.option"), Equals("StringOption")); os.DefineProperty("bool.option", &Options::bo, "BoolOption"); REQUIRE_THAT(os.PropertyGet("bool.option"), Equals("")); REQUIRE(SC_TYPE_BOOLEAN == os.PropertyType("bool.option")); REQUIRE_THAT(os.DescribeProperty("bool.option"), Equals("BoolOption")); os.DefineProperty("int.option", &Options::io, "IntOption"); REQUIRE_THAT(os.PropertyGet("int.option"), Equals("")); REQUIRE(SC_TYPE_INTEGER == os.PropertyType("int.option")); REQUIRE_THAT(os.DescribeProperty("int.option"), Equals("IntOption")); // This is really a set and could be reordered but is currently in definition order REQUIRE_THAT(os.PropertyNames(), Equals("string.option\nbool.option\nint.option")); } SECTION("Set") { os.DefineProperty("string.option", &Options::so, "StringOption"); REQUIRE_THAT(os.PropertyGet("string.option"), Equals("")); REQUIRE(os.PropertySet(&options, "string.option", "string")); REQUIRE_THAT(os.PropertyGet("string.option"), Equals("string")); // Setting to same as before returns false REQUIRE_FALSE(os.PropertySet(&options, "string.option", "string")); REQUIRE(os.PropertySet(&options, "string.option", "anotherString")); REQUIRE_THAT(os.PropertyGet("string.option"), Equals("anotherString")); os.DefineProperty("bool.option", &Options::so, "BoolOption"); REQUIRE(os.PropertySet(&options, "bool.option", "1")); REQUIRE_THAT(os.PropertyGet("bool.option"), Equals("1")); // Setting to same as before returns false REQUIRE_FALSE(os.PropertySet(&options, "bool.option", "1")); REQUIRE(os.PropertySet(&options, "bool.option", "0")); os.DefineProperty("int.option", &Options::so, "IntOption"); REQUIRE(os.PropertySet(&options, "int.option", "2")); REQUIRE_THAT(os.PropertyGet("int.option"), Equals("2")); // Setting to same as before returns false REQUIRE_FALSE(os.PropertySet(&options, "int.option", "2")); REQUIRE(os.PropertySet(&options, "int.option", "3")); } // WordListSets feature is really completely separate from options SECTION("WordListSets") { REQUIRE_THAT(os.DescribeWordListSets(), Equals("")); os.DefineWordListSets(denseWordLists); REQUIRE_THAT(os.DescribeWordListSets(), Equals("Keywords 1\nKeywords 2\nKeywords 3\nKeywords 4")); OptionSet os2; REQUIRE_THAT(os2.DescribeWordListSets(), Equals("")); os2.DefineWordListSets(sparseWordLists); REQUIRE_THAT(os2.DescribeWordListSets(), Equals("\n\nKeywords 1\n\nKeywords 2")); } } tmpok_q575y/lexilla/test/unit/UnitTester.vcxproj0000664000175000017500000002130014773064066021660 0ustar gusnangusnan Debug Win32 Release Win32 Debug x64 Release x64 {35688A27-D91B-453A-8A05-65A7F28DEFBF} Win32Proj UnitTester 10.0.16299.0 Application true v141 Unicode Application false v141 true Unicode Application true v141 Unicode Application false v141 true Unicode true true false false Level3 Disabled _CRT_SECURE_NO_WARNINGS=1;_HAS_AUTO_PTR_ETC=1;_SCL_SECURE_NO_WARNINGS=1;CHECK_CORRECTNESS;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) ..\..\include\;..\..\lexlib\;..\..\..\scintilla\include\ stdcpp17 Console true Level3 Disabled _CRT_SECURE_NO_WARNINGS=1;_HAS_AUTO_PTR_ETC=1;_SCL_SECURE_NO_WARNINGS=1;CHECK_CORRECTNESS;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) ..\..\include\;..\..\lexlib\;..\..\..\scintilla\include\ stdcpp17 Console true Level3 MaxSpeed true true _CRT_SECURE_NO_WARNINGS=1;_HAS_AUTO_PTR_ETC=1;_SCL_SECURE_NO_WARNINGS=1;CHECK_CORRECTNESS;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) ..\..\include\;..\..\lexlib\;..\..\..\scintilla\include\ stdcpp17 Console true true true Level3 MaxSpeed true true _CRT_SECURE_NO_WARNINGS=1;_HAS_AUTO_PTR_ETC=1;_SCL_SECURE_NO_WARNINGS=1;CHECK_CORRECTNESS;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) ..\..\include\;..\..\lexlib\;..\..\..\scintilla\include\ stdcpp17 Console true true true tmpok_q575y/lexilla/test/unit/catch.hpp0000664000175000017500000240400314773064066017737 0ustar gusnangusnan/* * Catch v2.13.10 * Generated: 2022-10-16 11:01:23.452308 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved. * * Distributed under the Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED // start catch.hpp #define CATCH_VERSION_MAJOR 2 #define CATCH_VERSION_MINOR 13 #define CATCH_VERSION_PATCH 10 #ifdef __clang__ # pragma clang system_header #elif defined __GNUC__ # pragma GCC system_header #endif // start catch_suppress_warnings.h #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(push) # pragma warning(disable: 161 1682) # else // __ICC # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wpadded" # pragma clang diagnostic ignored "-Wswitch-enum" # pragma clang diagnostic ignored "-Wcovered-switch-default" # endif #elif defined __GNUC__ // Because REQUIREs trigger GCC's -Wparentheses, and because still // supported version of g++ have only buggy support for _Pragmas, // Wparentheses have to be suppressed globally. # pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic ignored "-Wpadded" #endif // end catch_suppress_warnings.h #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) # define CATCH_IMPL # define CATCH_CONFIG_ALL_PARTS #endif // In the impl file, we want to have access to all parts of the headers // Can also be used to sanely support PCHs #if defined(CATCH_CONFIG_ALL_PARTS) # define CATCH_CONFIG_EXTERNAL_INTERFACES # if defined(CATCH_CONFIG_DISABLE_MATCHERS) # undef CATCH_CONFIG_DISABLE_MATCHERS # endif # if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) # define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER # endif #endif #if !defined(CATCH_CONFIG_IMPL_ONLY) // start catch_platform.h // See e.g.: // https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html #ifdef __APPLE__ # include # if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) # define CATCH_PLATFORM_MAC # elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) # define CATCH_PLATFORM_IPHONE # endif #elif defined(linux) || defined(__linux) || defined(__linux__) # define CATCH_PLATFORM_LINUX #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) # define CATCH_PLATFORM_WINDOWS #endif // end catch_platform.h #ifdef CATCH_IMPL # ifndef CLARA_CONFIG_MAIN # define CLARA_CONFIG_MAIN_NOT_DEFINED # define CLARA_CONFIG_MAIN # endif #endif // start catch_user_interfaces.h namespace Catch { unsigned int rngSeed(); } // end catch_user_interfaces.h // start catch_tag_alias_autoregistrar.h // start catch_common.h // start catch_compiler_capabilities.h // Detect a number of compiler features - by compiler // The following features are defined: // // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? // CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? // **************** // Note to maintainers: if new toggles are added please document them // in configuration.md, too // **************** // In general each macro has a _NO_ form // (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. // Many features, at point of detection, define an _INTERNAL_ macro, so they // can be combined, en-mass, with the _NO_ forms later. #ifdef __cplusplus # if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) # define CATCH_CPP14_OR_GREATER # endif # if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) # define CATCH_CPP17_OR_GREATER # endif #endif // Only GCC compiler should be used in this block, so other compilers trying to // mask themselves as GCC should be ignored. #if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) #endif #if defined(__clang__) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug // which results in calls to destructors being emitted for each temporary, // without a matching initialization. In practice, this can result in something // like `std::string::~string` being called on an uninitialized value. // // For example, this code will likely segfault under IBM XL: // ``` // REQUIRE(std::string("12") + "34" == "1234") // ``` // // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. # if !defined(__ibmxl__) && !defined(__CUDACC__) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ # endif # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // Assume that non-Windows platforms support posix signals by default #if !defined(CATCH_PLATFORM_WINDOWS) #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS #endif //////////////////////////////////////////////////////////////////////////////// // We know some environments not to support full POSIX signals #if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS #endif #ifdef __OS400__ # define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS # define CATCH_CONFIG_COLOUR_NONE #endif //////////////////////////////////////////////////////////////////////////////// // Android somehow still does not support std::to_string #if defined(__ANDROID__) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING # define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE #endif //////////////////////////////////////////////////////////////////////////////// // Not all Windows environments support SEH properly #if defined(__MINGW32__) # define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #endif //////////////////////////////////////////////////////////////////////////////// // PS4 #if defined(__ORBIS__) # define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE #endif //////////////////////////////////////////////////////////////////////////////// // Cygwin #ifdef __CYGWIN__ // Required for some versions of Cygwin to declare gettimeofday // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin # define _BSD_SOURCE // some versions of cygwin (most) do not support std::to_string. Use the libstd check. // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING # endif #endif // __CYGWIN__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #if defined(_MSC_VER) // Universal Windows platform does not support SEH // Or console colours (or console at all...) # if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) # define CATCH_CONFIG_COLOUR_NONE # else # define CATCH_INTERNAL_CONFIG_WINDOWS_SEH # endif # if !defined(__clang__) // Handle Clang masquerading for msvc // MSVC traditional preprocessor needs some workaround for __VA_ARGS__ // _MSVC_TRADITIONAL == 0 means new conformant preprocessor // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor # if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) # define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR # endif // MSVC_TRADITIONAL // Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop` # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) ) # endif // __clang__ #endif // _MSC_VER #if defined(_REENTRANT) || defined(_MSC_VER) // Enable async processing, as -pthread is specified or no additional linking is required # define CATCH_INTERNAL_CONFIG_USE_ASYNC #endif // _MSC_VER //////////////////////////////////////////////////////////////////////////////// // Check if we are compiled with -fno-exceptions or equivalent #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) # define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED #endif //////////////////////////////////////////////////////////////////////////////// // DJGPP #ifdef __DJGPP__ # define CATCH_INTERNAL_CONFIG_NO_WCHAR #endif // __DJGPP__ //////////////////////////////////////////////////////////////////////////////// // Embarcadero C++Build #if defined(__BORLANDC__) #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN #endif //////////////////////////////////////////////////////////////////////////////// // Use of __COUNTER__ is suppressed during code analysis in // CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly // handled by it. // Otherwise all supported compilers support COUNTER macro, // but user still might want to turn it off #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) #define CATCH_INTERNAL_CONFIG_COUNTER #endif //////////////////////////////////////////////////////////////////////////////// // RTX is a special version of Windows that is real time. // This means that it is detected as Windows, but does not provide // the same set of capabilities as real Windows does. #if defined(UNDER_RTSS) || defined(RTX64_BUILD) #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #define CATCH_INTERNAL_CONFIG_NO_ASYNC #define CATCH_CONFIG_COLOUR_NONE #endif #if !defined(_GLIBCXX_USE_C99_MATH_TR1) #define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER #endif // Various stdlib support checks that require __has_include #if defined(__has_include) // Check if string_view is available and usable #if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW #endif // Check if optional is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) // Check if byte is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # include # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) # define CATCH_INTERNAL_CONFIG_CPP17_BYTE # endif # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) // Check if variant is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # if defined(__clang__) && (__clang_major__ < 8) // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 // fix should be in clang 8, workaround in libstdc++ 8.2 # include # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # define CATCH_CONFIG_NO_CPP17_VARIANT # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__clang__) && (__clang_major__ < 8) # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) #endif // defined(__has_include) #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) # define CATCH_CONFIG_COUNTER #endif #if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) # define CATCH_CONFIG_WINDOWS_SEH #endif // This is set by default, because we assume that unix compilers are posix-signal-compatible by default. #if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) # define CATCH_CONFIG_POSIX_SIGNALS #endif // This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. #if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) # define CATCH_CONFIG_WCHAR #endif #if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) # define CATCH_CONFIG_CPP11_TO_STRING #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) # define CATCH_CONFIG_CPP17_OPTIONAL #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) # define CATCH_CONFIG_CPP17_STRING_VIEW #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) # define CATCH_CONFIG_CPP17_VARIANT #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) # define CATCH_CONFIG_CPP17_BYTE #endif #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) # define CATCH_INTERNAL_CONFIG_NEW_CAPTURE #endif #if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) # define CATCH_CONFIG_NEW_CAPTURE #endif #if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) # define CATCH_CONFIG_DISABLE_EXCEPTIONS #endif #if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) # define CATCH_CONFIG_POLYFILL_ISNAN #endif #if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) # define CATCH_CONFIG_USE_ASYNC #endif #if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) # define CATCH_CONFIG_ANDROID_LOGWRITE #endif #if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) # define CATCH_CONFIG_GLOBAL_NEXTAFTER #endif // Even if we do not think the compiler has that warning, we still have // to provide a macro that can be used by the code. #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION #endif #if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION #endif #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS #endif // The goal of this macro is to avoid evaluation of the arguments, but // still have the compiler warn on problems inside... #if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) #endif #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #elif defined(__clang__) && (__clang_major__ < 5) # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) #define CATCH_TRY if ((true)) #define CATCH_CATCH_ALL if ((false)) #define CATCH_CATCH_ANON(type) if ((false)) #else #define CATCH_TRY try #define CATCH_CATCH_ALL catch (...) #define CATCH_CATCH_ANON(type) catch (type) #endif #if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) #define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #endif // end catch_compiler_capabilities.h #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) #ifdef CATCH_CONFIG_COUNTER # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) #else # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #endif #include #include #include // We need a dummy global operator<< so we can bring it into Catch namespace later struct Catch_global_namespace_dummy {}; std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); namespace Catch { struct CaseSensitive { enum Choice { Yes, No }; }; class NonCopyable { NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; protected: NonCopyable(); virtual ~NonCopyable(); }; struct SourceLineInfo { SourceLineInfo() = delete; SourceLineInfo( char const* _file, std::size_t _line ) noexcept : file( _file ), line( _line ) {} SourceLineInfo( SourceLineInfo const& other ) = default; SourceLineInfo& operator = ( SourceLineInfo const& ) = default; SourceLineInfo( SourceLineInfo&& ) noexcept = default; SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; bool empty() const noexcept { return file[0] == '\0'; } bool operator == ( SourceLineInfo const& other ) const noexcept; bool operator < ( SourceLineInfo const& other ) const noexcept; char const* file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); // Bring in operator<< from global namespace into Catch namespace // This is necessary because the overload of operator<< above makes // lookup stop at namespace Catch using ::operator<<; // Use this in variadic streaming macros to allow // >> +StreamEndStop // as well as // >> stuff +StreamEndStop struct StreamEndStop { std::string operator+() const; }; template T const& operator + ( T const& value, StreamEndStop ) { return value; } } #define CATCH_INTERNAL_LINEINFO \ ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) // end catch_common.h namespace Catch { struct RegistrarForTagAliases { RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION // end catch_tag_alias_autoregistrar.h // start catch_test_registry.h // start catch_interfaces_testcase.h #include namespace Catch { class TestSpec; struct ITestInvoker { virtual void invoke () const = 0; virtual ~ITestInvoker(); }; class TestCase; struct IConfig; struct ITestCaseRegistry { virtual ~ITestCaseRegistry(); virtual std::vector const& getAllTests() const = 0; virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; }; bool isThrowSafe( TestCase const& testCase, IConfig const& config ); bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); std::vector const& getAllTestCasesSorted( IConfig const& config ); } // end catch_interfaces_testcase.h // start catch_stringref.h #include #include #include #include namespace Catch { /// A non-owning string class (similar to the forthcoming std::string_view) /// Note that, because a StringRef may be a substring of another string, /// it may not be null terminated. class StringRef { public: using size_type = std::size_t; using const_iterator = const char*; private: static constexpr char const* const s_empty = ""; char const* m_start = s_empty; size_type m_size = 0; public: // construction constexpr StringRef() noexcept = default; StringRef( char const* rawChars ) noexcept; constexpr StringRef( char const* rawChars, size_type size ) noexcept : m_start( rawChars ), m_size( size ) {} StringRef( std::string const& stdString ) noexcept : m_start( stdString.c_str() ), m_size( stdString.size() ) {} explicit operator std::string() const { return std::string(m_start, m_size); } public: // operators auto operator == ( StringRef const& other ) const noexcept -> bool; auto operator != (StringRef const& other) const noexcept -> bool { return !(*this == other); } auto operator[] ( size_type index ) const noexcept -> char { assert(index < m_size); return m_start[index]; } public: // named queries constexpr auto empty() const noexcept -> bool { return m_size == 0; } constexpr auto size() const noexcept -> size_type { return m_size; } // Returns the current start pointer. If the StringRef is not // null-terminated, throws std::domain_exception auto c_str() const -> char const*; public: // substrings and searches // Returns a substring of [start, start + length). // If start + length > size(), then the substring is [start, size()). // If start > size(), then the substring is empty. auto substr( size_type start, size_type length ) const noexcept -> StringRef; // Returns the current start pointer. May not be null-terminated. auto data() const noexcept -> char const*; constexpr auto isNullTerminated() const noexcept -> bool { return m_start[m_size] == '\0'; } public: // iterators constexpr const_iterator begin() const { return m_start; } constexpr const_iterator end() const { return m_start + m_size; } }; auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { return StringRef( rawChars, size ); } } // namespace Catch constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { return Catch::StringRef( rawChars, size ); } // end catch_stringref.h // start catch_preprocessor.hpp #define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ #define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) #ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ // MSVC needs more evaluations #define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) #else #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) #endif #define CATCH_REC_END(...) #define CATCH_REC_OUT #define CATCH_EMPTY() #define CATCH_DEFER(id) id CATCH_EMPTY() #define CATCH_REC_GET_END2() 0, CATCH_REC_END #define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 #define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 #define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT #define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) #define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) #define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) // Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, // and passes userdata as the first parameter to each invocation, // e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) #define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) #define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) #else // MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) #define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) #endif #define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ #define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) #else #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) #endif #define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) #define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) #define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) #define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) #define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) #define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) #define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) #define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6) #define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) #define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) #define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) #define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) #define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N #define INTERNAL_CATCH_TYPE_GEN\ template struct TypeList {};\ template\ constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ template class...> struct TemplateTypeList{};\ template class...Cs>\ constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ template\ struct append;\ template\ struct rewrap;\ template class, typename...>\ struct create;\ template class, typename>\ struct convert;\ \ template \ struct append { using type = T; };\ template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ template< template class L1, typename...E1, typename...Rest>\ struct append, TypeList, Rest...> { using type = L1; };\ \ template< template class Container, template class List, typename...elems>\ struct rewrap, List> { using type = TypeList>; };\ template< template class Container, template class List, class...Elems, typename...Elements>\ struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ \ template