├── .hgeol ├── .hgignore ├── .hgtags ├── CONTRIBUTING ├── License.txt ├── README ├── bin └── empty.txt ├── cppcheck.suppress ├── delbin.bat ├── doc ├── CommandValues.html ├── PaneAPI.html ├── PrintHi.png ├── SciBreak2.jpg ├── SciTE.html ├── SciTEDirector.html ├── SciTEDoc.html ├── SciTEDownload.html ├── SciTEExtension.html ├── SciTEExternalLexer.html ├── SciTEExtras.html ├── SciTEFAQ.html ├── SciTEHistory.html ├── SciTEIco.png ├── SciTEImage.html ├── SciTEIndicators.png ├── SciTELexer.html ├── SciTELogo.png ├── SciTELogo2x.png ├── SciTELua.html ├── SciTERegEx.html ├── SciTEWord.jpg ├── ScriptLexer.html ├── UserStrip.png ├── demo.png └── scite.1 ├── gtk ├── AppDepGen.py ├── DirectorExtension.cxx ├── DirectorExtension.h ├── GUIGTK.cxx ├── Sci48M.png ├── SciIcon.h ├── SciTE.desktop ├── SciTEGTK.cxx ├── Strips.cxx ├── Strips.h ├── Widget.cxx ├── Widget.h ├── deps.mak ├── lua.vers ├── makefile └── pixmapsGNOME.h ├── lua ├── COPYRIGHT └── src │ ├── lapi.c │ ├── lapi.h │ ├── lauxlib.c │ ├── lauxlib.h │ ├── lbaselib.c │ ├── lbitlib.c │ ├── lcode.c │ ├── lcode.h │ ├── lcorolib.c │ ├── lctype.c │ ├── lctype.h │ ├── ldblib.c │ ├── ldebug.c │ ├── ldebug.h │ ├── ldo.c │ ├── ldo.h │ ├── ldump.c │ ├── lfunc.c │ ├── lfunc.h │ ├── lgc.c │ ├── lgc.h │ ├── linit.c │ ├── liolib.c │ ├── llex.c │ ├── llex.h │ ├── llimits.h │ ├── lmathlib.c │ ├── lmem.c │ ├── lmem.h │ ├── loadlib.c │ ├── lobject.c │ ├── lobject.h │ ├── lopcodes.c │ ├── lopcodes.h │ ├── loslib.c │ ├── lparser.c │ ├── lparser.h │ ├── lprefix.h │ ├── lstate.c │ ├── lstate.h │ ├── lstring.c │ ├── lstring.h │ ├── lstrlib.c │ ├── ltable.c │ ├── ltable.h │ ├── ltablib.c │ ├── ltm.c │ ├── ltm.h │ ├── lua.h │ ├── lua.hpp │ ├── luaconf.h │ ├── lualib.h │ ├── lundump.c │ ├── lundump.h │ ├── lutf8lib.c │ ├── lvm.c │ ├── lvm.h │ ├── lzio.c │ └── lzio.h ├── scripts ├── CheckAtFile.py ├── CheckPropsDoc.py ├── HeaderOrder.txt ├── IFaceTableGen.py ├── PullSource.sh ├── RegenerateSource.py ├── ScintillaLogo.py ├── TagRelease.py ├── UpdateSizeInDocs.py ├── archive.sh ├── ba ├── builddist.bat ├── checkbuildlinux.sh ├── checkbuilds.bat ├── clearboth.bat ├── commandsdoc.py ├── makerpms.py ├── scite.spec └── tags2api.py ├── src ├── Cookie.cxx ├── Cookie.h ├── Credits.cxx ├── EditorConfig.cxx ├── EditorConfig.h ├── Embedded.properties ├── ExportHTML.cxx ├── ExportPDF.cxx ├── ExportRTF.cxx ├── ExportTEX.cxx ├── ExportXML.cxx ├── Extender.h ├── FilePath.cxx ├── FilePath.h ├── FileWorker.cxx ├── FileWorker.h ├── GUI.h ├── IFaceTable.cxx ├── IFaceTable.h ├── JobQueue.cxx ├── JobQueue.h ├── LuaExtension.cxx ├── LuaExtension.h ├── MatchMarker.cxx ├── MatchMarker.h ├── MultiplexExtension.cxx ├── MultiplexExtension.h ├── PathMatch.cxx ├── PathMatch.h ├── PropSetFile.cxx ├── PropSetFile.h ├── SciTE.h ├── SciTE.properties ├── SciTEBase.cxx ├── SciTEBase.h ├── SciTEBuffers.cxx ├── SciTEGlobal.properties ├── SciTEIO.cxx ├── SciTEKeys.h ├── SciTEProps.cxx ├── ScintillaWindow.cxx ├── ScintillaWindow.h ├── Searcher.h ├── StringHelpers.cxx ├── StringHelpers.h ├── StringList.cxx ├── StringList.h ├── StripDefinition.h ├── StyleDefinition.cxx ├── StyleDefinition.h ├── StyleWriter.cxx ├── StyleWriter.h ├── Utf8_16.cxx ├── Utf8_16.h ├── Worker.h ├── abaqus.properties ├── abbrev.properties ├── ada.properties ├── asciidoc.properties ├── asl.properties ├── asm.properties ├── asn1.properties ├── au3.properties ├── ave.properties ├── avs.properties ├── baan.properties ├── blitzbasic.properties ├── bullant.properties ├── caml.properties ├── cil.properties ├── cmake.properties ├── cobol.properties ├── coffeescript.properties ├── conf.properties ├── cpp.properties ├── csound.properties ├── css.properties ├── d.properties ├── dataflex.properties ├── ecl.properties ├── eiffel.properties ├── erlang.properties ├── escript.properties ├── flagship.properties ├── forth.properties ├── fortran.properties ├── freebasic.properties ├── fsharp.properties ├── gap.properties ├── haskell.properties ├── hex.properties ├── hollywood.properties ├── html.properties ├── inno.properties ├── json.properties ├── kix.properties ├── latex.properties ├── lexillaVersion.txt ├── lisp.properties ├── lot.properties ├── lout.properties ├── lua.properties ├── markdown.properties ├── matlab.properties ├── maxima.properties ├── metapost.properties ├── mmixal.properties ├── modula3.properties ├── nim.properties ├── nncrontab.properties ├── nsis.properties ├── opal.properties ├── oscript.properties ├── others.properties ├── pascal.properties ├── perl.properties ├── pov.properties ├── powerpro.properties ├── powershell.properties ├── ps.properties ├── purebasic.properties ├── python.properties ├── r.properties ├── raku.properties ├── rebol.properties ├── registry.properties ├── ruby.properties ├── rust.properties ├── sas.properties ├── scintillaVersion.txt ├── scite_lua_win.h ├── scriptol.properties ├── smalltalk.properties ├── sorcins.properties ├── specman.properties ├── spice.properties ├── sql.properties ├── tacl.properties ├── tal.properties ├── tcl.properties ├── tex.properties ├── troff.properties ├── txt2tags.properties ├── vb.properties ├── verilog.properties ├── vhdl.properties ├── visualprolog.properties └── yaml.properties ├── test ├── UnitTester.cxx ├── UnitTester.vcxproj ├── catch.hpp ├── makefile ├── test.mak ├── testUtf8_16.cxx └── unitTest.cxx ├── tgzgscite ├── tgzsrc ├── upxsc1.bat ├── version.txt ├── win32 ├── AppDepGen.py ├── DLLFunction.h ├── DirectorExtension.cxx ├── DirectorExtension.h ├── DragDrop.cur ├── GUIWin.cxx ├── SciBall.ico ├── SciTE.exe.manifest ├── SciTE.vcxproj ├── SciTERes.rc ├── SciTEWin.cxx ├── SciTEWin.h ├── SciTEWinBar.cxx ├── SciTEWinDlg.cxx ├── Strips.cxx ├── Strips.h ├── UniqueInstance.cxx ├── UniqueInstance.h ├── around.bmp ├── around20.bmp ├── around24.bmp ├── around32.bmp ├── backslash.bmp ├── backslash20.bmp ├── backslash24.bmp ├── backslash32.bmp ├── case.bmp ├── case20.bmp ├── case24.bmp ├── case32.bmp ├── closefile.bmp ├── closefile24.bmp ├── context.bmp ├── context20.bmp ├── context24.bmp ├── context32.bmp ├── deps.mak ├── filter.bmp ├── filter20.bmp ├── filter24.bmp ├── filter32.bmp ├── locale.properties ├── makefile ├── nmdeps.mak ├── regex.bmp ├── regex20.bmp ├── regex24.bmp ├── regex32.bmp ├── scite.mak ├── up.bmp ├── up20.bmp ├── up24.bmp ├── up32.bmp ├── word.bmp ├── word20.bmp ├── word24.bmp └── word32.bmp ├── zipsrc.bat ├── zipwscite.bat └── zipwscited.bat /.hgeol: -------------------------------------------------------------------------------- 1 | [patterns] 2 | **.cxx = native 3 | **.c = native 4 | **.h = native 5 | **.py = native 6 | **.rc = native 7 | **.html = native 8 | **.bat = native 9 | **.mak = native 10 | **makefile = native 11 | **.manifest = native 12 | **.properties = native 13 | **.dsp = native 14 | **.sln = native 15 | **.vcproj = native 16 | **.gen = native 17 | **.bmp = BIN 18 | **.cur = BIN 19 | **.ico = BIN 20 | **.jpg = BIN 21 | **.png = BIN 22 | tgzsrc = LF 23 | scripts/ba = LF 24 | -------------------------------------------------------------------------------- /.hgignore: -------------------------------------------------------------------------------- 1 | syntax: glob 2 | *.o 3 | *.a 4 | *.obj 5 | *.iobj 6 | __pycache__ 7 | *.pyc 8 | *.dll 9 | *.so 10 | *.dylib 11 | *.exe 12 | *.exp 13 | *.lib 14 | *.pdb 15 | *.ipdb 16 | *.res 17 | *.bak 18 | *.sbr 19 | *.suo 20 | *.aps 21 | *.vcxproj.* 22 | *.idb 23 | *.bsc 24 | *.intermediate.manifest 25 | *.lastbuildstate 26 | *.nativecodeanalysis.xml 27 | *.nativecodeanalysis.all.xml 28 | *.lastcodeanalysissucceeded 29 | *.ilk 30 | *.psess 31 | *.ncb 32 | *.tlog 33 | *.ipch 34 | *.old 35 | *.sdf 36 | *.diagsession 37 | *.vspx 38 | *.opensdf 39 | *.tgz 40 | *.log 41 | .DS_Store 42 | Release 43 | Debug 44 | x64 45 | ARM64 46 | _UpgradeReport_Files 47 | UpgradeLog.XML 48 | bin 49 | BuildLog.htm 50 | cov-int 51 | .vs 52 | -------------------------------------------------------------------------------- /CONTRIBUTING: -------------------------------------------------------------------------------- 1 | Fixes should be posted to the Bug Tracker 2 | http://sourceforge.net/p/scintilla/bugs/ 3 | 4 | Features should be posted to the Feature Request Tracker 5 | http://sourceforge.net/p/scintilla/feature-requests/ 6 | 7 | Either send unified diffs (or patch files) or zip archives with whole files. 8 | Mercurial patch files are best as they include author information and commit 9 | messages. 10 | 11 | Questions should go to the scite-interest mailing list 12 | https://groups.google.com/forum/#!forum/scite-interest 13 | 14 | Code should follow the guidelines at 15 | http://www.scintilla.org/SciCoding.html 16 | 17 | Do not use SourceForge's Merge Request mechanism or message sending 18 | feature as no one is monitoring these. 19 | The neilh @ scintilla.org account receives much spam and is only checked 20 | occasionally. Almost all SciTE mail should go to the mailing list. -------------------------------------------------------------------------------- /License.txt: -------------------------------------------------------------------------------- 1 | License for Lexilla, Scintilla, and SciTE 2 | 3 | Copyright 1998-2021 by Neil Hodgson 4 | 5 | All Rights Reserved 6 | 7 | Permission to use, copy, modify, and distribute this software and its 8 | documentation for any purpose and without fee is hereby granted, 9 | provided that the above copyright notice appear in all copies and that 10 | both that copyright notice and this permission notice appear in 11 | supporting documentation. 12 | 13 | NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 14 | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 15 | AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY 16 | SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 17 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 18 | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 19 | TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE 20 | OR PERFORMANCE OF THIS SOFTWARE. -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | README for building of Scintilla, Lexilla, and SciTE 2 | 3 | Scintilla and Lexilla can be built by themselves. 4 | To build SciTE, Scintilla and Lexilla should first be built. 5 | 6 | See lexilla/README for information on building Lexilla. 7 | 8 | *** GTK+/Linux version *** 9 | 10 | You must first have GTK+ 2.24 or later and GCC (7.1 or better) installed. 11 | Clang may be used by adding CLANG=1 to the make command line. 12 | Other C++ compilers may work but may require tweaking the make file. 13 | Either GTK+ 2.x or 3.x may be used with 2.x the default and 3.x 14 | chosen with the make argument GTK3=1. 15 | 16 | To build Scintilla, use the makefile located in the scintilla/gtk directory 17 | cd scintilla/gtk 18 | make 19 | cd ../.. 20 | 21 | To build and install SciTE, use the makefile located in the scite/gtk directory 22 | cd scite/gtk 23 | make 24 | sudo make install 25 | 26 | This installs SciTE into $prefix/bin. The value of $prefix is determined from 27 | the location of Gnome if it is installed. This is usually /usr if installed 28 | with Linux or /usr/local if built from source. If Gnome is not installed 29 | /usr/bin is used as the prefix. The prefix can be overridden on the command 30 | line like "make prefix=/opt" but the same value should be used for both make 31 | and make install as this location is compiled into the executable. The global 32 | properties file is installed at $prefix/share/scite/SciTEGlobal.properties. 33 | The language specific properties files are also installed into this directory. 34 | 35 | To remove SciTE 36 | sudo make uninstall 37 | 38 | To clean the object files which may be needed to change $prefix 39 | make clean 40 | 41 | The current make file supports static and dynamic linking between SciTE, Scintilla, and Lexilla. 42 | 43 | 44 | *** Windows version *** 45 | 46 | A C++ 17 compiler is required. 47 | Visual Studio 2019 is the development system used for most development 48 | although Mingw-w64 9.2 is also supported. 49 | 50 | To build Scintilla, make in the scintilla/win32 directory 51 | cd scintilla\win32 52 | GCC: mingw32-make 53 | Visual C++: nmake -f scintilla.mak 54 | cd ..\.. 55 | 56 | To build SciTE, use the makefiles located in the scite/win32 directory 57 | cd scite\win32 58 | GCC: mingw32-make 59 | Visual C++: nmake -f scite.mak 60 | 61 | An executable SciTE will now be in scite/bin. 62 | 63 | *** GTK+/Windows version *** 64 | 65 | Mingw-w64 is known to work. Other compilers will probably not work. 66 | 67 | Only Scintilla will build with GTK+ on Windows. SciTE will not work. 68 | 69 | Make builds both a static library version of Scintilla with lexers (scintilla.a) and 70 | a shared library without lexers (libscintilla.so or or libscintilla.dll). 71 | 72 | To build Scintilla, make in the scintilla/gtk directory 73 | cd scintilla\gtk 74 | mingw32-make 75 | 76 | *** macOS Cocoa version *** 77 | 78 | Xcode 9.2 or later may be used to build Scintilla on macOS. 79 | 80 | There is no open source version of SciTE for macOS but there is a commercial 81 | version available through the App Store. 82 | 83 | To build Scintilla, run xcodebuild in the scintilla/cocoa/ScintillaFramework or 84 | scintilla/cocoa/Scintilla directory 85 | 86 | cd cocoa/Scintilla 87 | 88 | xcodebuild 89 | 90 | *** Qt version *** 91 | 92 | See the qt/README file to build Scintilla with Qt. 93 | -------------------------------------------------------------------------------- /bin/empty.txt: -------------------------------------------------------------------------------- 1 | This empty files ensures that the directory is created. -------------------------------------------------------------------------------- /cppcheck.suppress: -------------------------------------------------------------------------------- 1 | // File to suppress cppcheck warnings for files that will not be fixed. 2 | // Does not suppress warnings where an additional occurrence of the warning may be of interest. 3 | // Configured for cppcheck 2.15 4 | 5 | // Just a report of how many checkers are run 6 | checkersReport 7 | 8 | // This just warns that cppcheck isn't exhaustive and it still appears in exhaustive mode 9 | normalCheckLevelMaxBranches 10 | 11 | // These may be interesting but its not clear without examining each instance closely 12 | useStlAlgorithm 13 | 14 | // Coding style is to use assignments in constructor when there are many 15 | // members to initialize or the initialization is complex or has comments. 16 | useInitializationList 17 | 18 | // These are placeholders showing where to place code if ever wanted 19 | uselessOverride 20 | 21 | // FilePath has a non-explicit constructor used for conversions 22 | noExplicitConstructor:scite/src/FilePath.h 23 | 24 | // Cppcheck wrongly assumes string_view::remove_prefix can not empty the view 25 | knownConditionTrueFalse:scite/src/FilePath.cxx 26 | 27 | // cppcheck 2.11 can't find system headers on Win32. 28 | missingIncludeSystem 29 | 30 | // Windows and GTK define classes with the same name 31 | ctuOneDefinitionRuleViolation:scite/win32/Strips.h 32 | ctuOneDefinitionRuleViolation:scite/gtk/Widget.h 33 | ctuOneDefinitionRuleViolation:scite/gtk/Strips.h 34 | 35 | // This is an unusual case where a pointer inside a std::string is needed later in the code. 36 | variableScope:scite/src/SciTEBase.cxx 37 | 38 | // Accessing 0th element of string is OK. Only triggers on non-threaded runs. 39 | //ctuArrayIndex:scite/src/SciTEBuffers.cxx 40 | 41 | // Cppcheck seems to be assuming only first condition (start < length) can cause loop termination 42 | knownConditionTrueFalse:scite/src/SciTEIO.cxx 43 | 44 | // This code is using NULs inside strings to terminate early so fixing warning causes failure. 45 | stlcstrConstructor:scite/gtk/SciTEGTK.cxx 46 | 47 | // gtk_print_operation_set_default_page_setup takes a non const pointer so ancestor variables should be non-const 48 | constVariablePointer:scite/gtk/SciTEGTK.cxx 49 | 50 | // Changing events to const pointers changes signature and would require casts when hooking up 51 | constParameterCallback:scite/gtk/SciTEGTK.cxx 52 | constParameterPointer:scite/gtk/SciTEGTK.cxx 53 | constParameterCallback:scite/gtk/Widget.cxx 54 | constParameterCallback:scite/gtk/Strips.cxx 55 | // Since LuaPanicFunction is callback of form prescribed by Lua match signature exactly rather than add const 56 | constParameterCallback:scite/src/LuaExtension.cxx 57 | 58 | // A judgement call: value semantics avoids potential for lifetime bugs at cost of performance 59 | returnByReference:scite/src/StringHelpers.h 60 | 61 | // Don't understand what is happening here in SwitchDocumentAt 62 | constParameterPointer:scite/src/SciTEBuffers.cxx 63 | 64 | // Not using const pointer as called method TextWritten may change to mutate argument 65 | constParameterPointer:scite/src/SciTEIO.cxx 66 | 67 | // Menu::Show is cross-platform and may have to mutate its second argument 68 | constParameterReference:scite/win32/GUIWin.cxx 69 | 70 | // Prefer uniform use of | instead of special casing first which is just assignment 71 | badBitmaskCheck:scite/win32/SciTEWin.cxx 72 | 73 | // Suppress everything in lua as that comes from the Lua distribution 74 | *:scite/lua/* 75 | 76 | // Suppress everything in catch.hpp as won't be changing 77 | *:scite/test/catch.hpp 78 | 79 | // cppcheck doesn't understand ""sv literals 80 | unknownMacro:scite/test/testUtf8_16.cxx 81 | -------------------------------------------------------------------------------- /delbin.bat: -------------------------------------------------------------------------------- 1 | @del /S /Q *.a *.aps *.bsc *.dll *.dsw *.exe *.idb *.ilc *.ild *.ilf *.ilk *.ils *.lib *.map *.ncb *.obj *.o *.opt *.ipdb *.pdb *.plg *.res *.sbr *.tds *.exp *.tlog *.lastbuildstate *.plist >NUL: 2 | -------------------------------------------------------------------------------- /doc/PrintHi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/PrintHi.png -------------------------------------------------------------------------------- /doc/SciBreak2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciBreak2.jpg -------------------------------------------------------------------------------- /doc/SciTEExternalLexer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 9 | 13 | 14 |
7 | Scintilla icon 8 | 10 | 11 | Add an external lexer to SciTE 12 |
15 |

16 | Lexer addition. 17 |

18 |

This document has been superceded.

19 | 20 | 21 | -------------------------------------------------------------------------------- /doc/SciTEIco.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciTEIco.png -------------------------------------------------------------------------------- /doc/SciTEImage.html: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | Scintilla and SciTE 11 | 12 | 13 | 14 | 15 | 16 | 19 | 23 | 24 |
17 | Scintilla icon 18 | 20 | Scintilla 21 | and SciTE 22 |
25 |
26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /doc/SciTEIndicators.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciTEIndicators.png -------------------------------------------------------------------------------- /doc/SciTELogo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciTELogo.png -------------------------------------------------------------------------------- /doc/SciTELogo2x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciTELogo2x.png -------------------------------------------------------------------------------- /doc/SciTEWord.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/SciTEWord.jpg -------------------------------------------------------------------------------- /doc/UserStrip.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/UserStrip.png -------------------------------------------------------------------------------- /doc/demo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/doc/demo.png -------------------------------------------------------------------------------- /doc/scite.1: -------------------------------------------------------------------------------- 1 | .TH SCITE 1 "2001 February 26" 2 | .SH NAME 3 | SciTE \- a programmers text editor 4 | .SH SYNOPSIS 5 | .br 6 | .B SciTE 7 | [file ..] 8 | .SH DESCRIPTION 9 | .B SciTE 10 | is a graphical GTK+ based editor. It has support 11 | for indenting, highlighting, and shortcuts in a myriad 12 | of languages and can be extended by editing object-oriented 13 | configuration files. 14 | .PP 15 | Support is included for Java, C, C++, C#, Shell, Apache. 16 | .SH ON-LINE HELP 17 | Type Alt-H or Click the Help Pulldown menu. 18 | .SH AUTHOR 19 | Most of 20 | .B SciTE 21 | was made by Neil Hodgson, with a lot of help from others. 22 | See Help 23 | .br 24 | .SH BUGS 25 | Probably. 26 | -------------------------------------------------------------------------------- /gtk/AppDepGen.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # AppDepGen.py - produce a make dependencies file for SciTE 3 | # Copyright 2019 by Neil Hodgson 4 | # The License.txt file describes the conditions under which this software may be distributed. 5 | # Requires Python 3.6 or later 6 | 7 | import sys 8 | 9 | srcRoot = "../.." 10 | 11 | sys.path.append(srcRoot + "/scintilla") 12 | 13 | from scripts import Dependencies 14 | 15 | topComment = "# Created by AppDepGen.py. To recreate, run AppDepGen.py.\n" 16 | 17 | def Generate(): 18 | sciteSources = ["../src/*.cxx", "../lua/src/*.c", "../../lexilla/access/*.cxx", "../../scintilla/call/*.cxx"] 19 | sciteIncludes = ["../../lexilla/include", "../../lexilla/access", "../../scintilla/include", "../src", "../lua/src"] 20 | 21 | deps = Dependencies.FindDependencies(["../gtk/*.cxx"] + sciteSources, ["../gtk"] + sciteIncludes, ".o", "../gtk/") 22 | Dependencies.UpdateDependencies("../gtk/deps.mak", deps, topComment) 23 | 24 | if __name__ == "__main__": 25 | Generate() -------------------------------------------------------------------------------- /gtk/DirectorExtension.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file DirectorExtension.h 3 | ** Extension for communicating with a director program. 4 | **/ 5 | // Copyright 1998-2001 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef DIRECTOREXTENSION_H 9 | #define DIRECTOREXTENSION_H 10 | 11 | class DirectorExtension : public Extension { 12 | private: 13 | DirectorExtension() : inputWatcher(-1), inputChannel(0), host(0) {} // Singleton 14 | DirectorExtension(const DirectorExtension &); // Disable copy ctor 15 | void operator=(const DirectorExtension &); // Disable operator= 16 | 17 | public: 18 | static DirectorExtension &Instance(); 19 | 20 | // Implement the Extension interface 21 | bool Initialise(ExtensionAPI *host_) override; 22 | bool Finalise() noexcept override; 23 | bool Clear() override; 24 | bool Load(const char *filename) override; 25 | 26 | bool OnOpen(const char *path) override; 27 | bool OnSwitchFile(const char *path) override; 28 | bool OnSave(const char *path) override; 29 | bool OnChar(char ch) override; 30 | bool OnExecute(const char *cmd) override; 31 | bool OnSavePointReached() override; 32 | bool OnSavePointLeft() override; 33 | bool OnStyle(SA::Position startPos, SA::Position lengthDoc, int initStyle, StyleWriter *styler) override; 34 | bool OnDoubleClick() override; 35 | bool OnUpdateUI() override; 36 | bool OnMarginClick() override; 37 | bool OnMacro(const char *command, const char *params) override; 38 | 39 | bool SendProperty(const char *prop) override; 40 | bool OnClose(const char *path) override; 41 | bool NeedsOnClose() override; 42 | 43 | // Allow messages through to extension 44 | void HandleStringMessage(const char *message); 45 | 46 | void CreatePipe(bool forceNew = false); 47 | private: 48 | int inputWatcher; 49 | GIOChannel *inputChannel; 50 | ExtensionAPI *host; 51 | }; 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /gtk/Sci48M.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/gtk/Sci48M.png -------------------------------------------------------------------------------- /gtk/SciIcon.h: -------------------------------------------------------------------------------- 1 | // @file SciIcon.h 2 | /* XPM */ 3 | static const char * SciIcon_xpm[] = { 4 | "16 16 17 1", 5 | " c None", 6 | ". c #666666", 7 | "+ c #424242", 8 | "@ c #4D4D4D", 9 | "# c #777777", 10 | "$ c #555555", 11 | "% c #868686", 12 | "& c #333333", 13 | "* c #292929", 14 | "= c #A0A0A4", 15 | "- c #808080", 16 | "; c #C0C0C0", 17 | "> c #999999", 18 | ", c #E3E3E3", 19 | "' c #161616", 20 | ") c #B2B2B2", 21 | "! c #D7D7D7", 22 | " .+@@+# ", 23 | " $+$$@+@+@$ ", 24 | " $@+%&.@@@++@ ", 25 | " $@*=@-@-&.+&&@ ", 26 | " #+@;*>#&>&@+*+ ", 27 | ".$*;*,*=='..'++&", 28 | "+&.%#.,*$;&*.&*&", 29 | "*@)*,$+,@&=.'&.'", 30 | "*$&;*,$*!=*+%$''", 31 | "**@$)*;%*.;$***'", 32 | "*&&&&$*#-&*@+&''", 33 | " **&@*$**@+*''' ", 34 | " &*&+.'++*'*&** ", 35 | " **&*+&*&&*'' ", 36 | " ********'' ", 37 | " *''''' "}; 38 | -------------------------------------------------------------------------------- /gtk/SciTE.desktop: -------------------------------------------------------------------------------- 1 | [Desktop Entry] 2 | Version=1.0 3 | Name=SciTE Text Editor 4 | Name[da]=SciTE-tekstredigering 5 | Name[de]=SciTE-Textbearbeitung 6 | Name[es]=Editor de textos SciTE 7 | Name[fr]=Éditeur de texte SciTE 8 | Name[ru]=Текстовый редактор SciTE 9 | Comment=Edit your source files 10 | Comment[da]=Rediger dine kildefiler 11 | Comment[de]=Quelltextdateien bearbeiten 12 | Comment[es]=Edita especializado para programación 13 | Comment[fr]=Éditer des fichiers sources 14 | Comment[ru]=Редактор исходных кодов 15 | GenericName=Text Editor 16 | GenericName[de]=Textbearbeitung 17 | Type=Application 18 | Exec=SciTE %F 19 | Icon=Sci48M 20 | Terminal=false 21 | StartupNotify=true 22 | Categories=TextEditor;Development;GTK; 23 | MimeType=text/plain; 24 | -------------------------------------------------------------------------------- /lua/COPYRIGHT: -------------------------------------------------------------------------------- 1 | Lua License 2 | ----------- 3 | 4 | Lua is licensed under the terms of the MIT license reproduced below. 5 | This means that Lua is free software and can be used for both academic 6 | and commercial purposes at absolutely no cost. 7 | 8 | For details and rationale, see http://www.lua.org/license.html . 9 | 10 | =============================================================================== 11 | 12 | Copyright (C) 1994-2017 Lua.org, PUC-Rio. 13 | 14 | Permission is hereby granted, free of charge, to any person obtaining a copy 15 | of this software and associated documentation files (the "Software"), to deal 16 | in the Software without restriction, including without limitation the rights 17 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 18 | copies of the Software, and to permit persons to whom the Software is 19 | furnished to do so, subject to the following conditions: 20 | 21 | The above copyright notice and this permission notice shall be included in 22 | all copies or substantial portions of the Software. 23 | 24 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 27 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 30 | THE SOFTWARE. 31 | 32 | =============================================================================== 33 | 34 | (end of COPYRIGHT) 35 | -------------------------------------------------------------------------------- /lua/src/lapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lapi.h,v 2.9 2015/03/06 19:49:50 roberto Exp $ 3 | ** Auxiliary functions from Lua API 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lapi_h 8 | #define lapi_h 9 | 10 | 11 | #include "llimits.h" 12 | #include "lstate.h" 13 | 14 | #define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \ 15 | "stack overflow");} 16 | 17 | #define adjustresults(L,nres) \ 18 | { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; } 19 | 20 | #define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \ 21 | "not enough elements in the stack") 22 | 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /lua/src/lcode.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lcode.h,v 1.64 2016/01/05 16:22:37 roberto Exp $ 3 | ** Code generator for Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lcode_h 8 | #define lcode_h 9 | 10 | #include "llex.h" 11 | #include "lobject.h" 12 | #include "lopcodes.h" 13 | #include "lparser.h" 14 | 15 | 16 | /* 17 | ** Marks the end of a patch list. It is an invalid value both as an absolute 18 | ** address, and as a list link (would link an element to itself). 19 | */ 20 | #define NO_JUMP (-1) 21 | 22 | 23 | /* 24 | ** grep "ORDER OPR" if you change these enums (ORDER OP) 25 | */ 26 | typedef enum BinOpr { 27 | OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW, 28 | OPR_DIV, 29 | OPR_IDIV, 30 | OPR_BAND, OPR_BOR, OPR_BXOR, 31 | OPR_SHL, OPR_SHR, 32 | OPR_CONCAT, 33 | OPR_EQ, OPR_LT, OPR_LE, 34 | OPR_NE, OPR_GT, OPR_GE, 35 | OPR_AND, OPR_OR, 36 | OPR_NOBINOPR 37 | } BinOpr; 38 | 39 | 40 | typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; 41 | 42 | 43 | /* get (pointer to) instruction of given 'expdesc' */ 44 | #define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) 45 | 46 | #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) 47 | 48 | #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) 49 | 50 | #define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) 51 | 52 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); 53 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); 54 | LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k); 55 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line); 56 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); 57 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); 58 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); 59 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s); 60 | LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n); 61 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); 62 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); 63 | LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e); 64 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e); 65 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e); 66 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e); 67 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key); 68 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); 69 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e); 70 | LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e); 71 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); 72 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults); 73 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e); 74 | LUAI_FUNC int luaK_jump (FuncState *fs); 75 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret); 76 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target); 77 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list); 78 | LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level); 79 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2); 80 | LUAI_FUNC int luaK_getlabel (FuncState *fs); 81 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line); 82 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); 83 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, 84 | expdesc *v2, int line); 85 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore); 86 | 87 | 88 | #endif 89 | -------------------------------------------------------------------------------- /lua/src/lctype.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lctype.c,v 1.12 2014/11/02 19:19:04 roberto Exp $ 3 | ** 'ctype' functions for Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #define lctype_c 8 | #define LUA_CORE 9 | 10 | #include "lprefix.h" 11 | 12 | 13 | #include "lctype.h" 14 | 15 | #if !LUA_USE_CTYPE /* { */ 16 | 17 | #include 18 | 19 | LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = { 20 | 0x00, /* EOZ */ 21 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */ 22 | 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 23 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */ 24 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 25 | 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */ 26 | 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 27 | 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */ 28 | 0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 29 | 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */ 30 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 31 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */ 32 | 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05, 33 | 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */ 34 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 35 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */ 36 | 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00, 37 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */ 38 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 39 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */ 40 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 41 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */ 42 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 43 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */ 44 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 45 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */ 46 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 47 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */ 48 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 49 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */ 50 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 51 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */ 52 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 53 | }; 54 | 55 | #endif /* } */ 56 | -------------------------------------------------------------------------------- /lua/src/lctype.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $ 3 | ** 'ctype' functions for Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lctype_h 8 | #define lctype_h 9 | 10 | #include "lua.h" 11 | 12 | 13 | /* 14 | ** WARNING: the functions defined here do not necessarily correspond 15 | ** to the similar functions in the standard C ctype.h. They are 16 | ** optimized for the specific needs of Lua 17 | */ 18 | 19 | #if !defined(LUA_USE_CTYPE) 20 | 21 | #if 'A' == 65 && '0' == 48 22 | /* ASCII case: can use its own tables; faster and fixed */ 23 | #define LUA_USE_CTYPE 0 24 | #else 25 | /* must use standard C ctype */ 26 | #define LUA_USE_CTYPE 1 27 | #endif 28 | 29 | #endif 30 | 31 | 32 | #if !LUA_USE_CTYPE /* { */ 33 | 34 | #include 35 | 36 | #include "llimits.h" 37 | 38 | 39 | #define ALPHABIT 0 40 | #define DIGITBIT 1 41 | #define PRINTBIT 2 42 | #define SPACEBIT 3 43 | #define XDIGITBIT 4 44 | 45 | 46 | #define MASK(B) (1 << (B)) 47 | 48 | 49 | /* 50 | ** add 1 to char to allow index -1 (EOZ) 51 | */ 52 | #define testprop(c,p) (luai_ctype_[(c)+1] & (p)) 53 | 54 | /* 55 | ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_' 56 | */ 57 | #define lislalpha(c) testprop(c, MASK(ALPHABIT)) 58 | #define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) 59 | #define lisdigit(c) testprop(c, MASK(DIGITBIT)) 60 | #define lisspace(c) testprop(c, MASK(SPACEBIT)) 61 | #define lisprint(c) testprop(c, MASK(PRINTBIT)) 62 | #define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) 63 | 64 | /* 65 | ** this 'ltolower' only works for alphabetic characters 66 | */ 67 | #define ltolower(c) ((c) | ('A' ^ 'a')) 68 | 69 | 70 | /* two more entries for 0 and -1 (EOZ) */ 71 | LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2]; 72 | 73 | 74 | #else /* }{ */ 75 | 76 | /* 77 | ** use standard C ctypes 78 | */ 79 | 80 | #include 81 | 82 | 83 | #define lislalpha(c) (isalpha(c) || (c) == '_') 84 | #define lislalnum(c) (isalnum(c) || (c) == '_') 85 | #define lisdigit(c) (isdigit(c)) 86 | #define lisspace(c) (isspace(c)) 87 | #define lisprint(c) (isprint(c)) 88 | #define lisxdigit(c) (isxdigit(c)) 89 | 90 | #define ltolower(c) (tolower(c)) 91 | 92 | #endif /* } */ 93 | 94 | #endif 95 | 96 | -------------------------------------------------------------------------------- /lua/src/ldebug.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ldebug.h,v 2.14 2015/05/22 17:45:56 roberto Exp $ 3 | ** Auxiliary functions from Debug Interface module 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ldebug_h 8 | #define ldebug_h 9 | 10 | 11 | #include "lstate.h" 12 | 13 | 14 | #define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1) 15 | 16 | #define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1) 17 | 18 | #define resethookcount(L) (L->hookcount = L->basehookcount) 19 | 20 | 21 | LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, 22 | const char *opname); 23 | LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1, 24 | const TValue *p2); 25 | LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1, 26 | const TValue *p2, 27 | const char *msg); 28 | LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1, 29 | const TValue *p2); 30 | LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1, 31 | const TValue *p2); 32 | LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...); 33 | LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg, 34 | TString *src, int line); 35 | LUAI_FUNC l_noret luaG_errormsg (lua_State *L); 36 | LUAI_FUNC void luaG_traceexec (lua_State *L); 37 | 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /lua/src/ldo.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ldo.h,v 2.29 2015/12/21 13:02:14 roberto Exp $ 3 | ** Stack and Call structure of Lua 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ldo_h 8 | #define ldo_h 9 | 10 | 11 | #include "lobject.h" 12 | #include "lstate.h" 13 | #include "lzio.h" 14 | 15 | 16 | /* 17 | ** Macro to check stack size and grow stack if needed. Parameters 18 | ** 'pre'/'pos' allow the macro to preserve a pointer into the 19 | ** stack across reallocations, doing the work only when needed. 20 | ** 'condmovestack' is used in heavy tests to force a stack reallocation 21 | ** at every check. 22 | */ 23 | #define luaD_checkstackaux(L,n,pre,pos) \ 24 | if (L->stack_last - L->top <= (n)) \ 25 | { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); } 26 | 27 | /* In general, 'pre'/'pos' are empty (nothing to save) */ 28 | #define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) 29 | 30 | 31 | 32 | #define savestack(L,p) ((char *)(p) - (char *)L->stack) 33 | #define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) 34 | 35 | 36 | /* type of protected functions, to be ran by 'runprotected' */ 37 | typedef void (*Pfunc) (lua_State *L, void *ud); 38 | 39 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name, 40 | const char *mode); 41 | LUAI_FUNC void luaD_hook (lua_State *L, int event, int line); 42 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults); 43 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults); 44 | LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults); 45 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, 46 | ptrdiff_t oldtop, ptrdiff_t ef); 47 | LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, 48 | int nres); 49 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); 50 | LUAI_FUNC void luaD_growstack (lua_State *L, int n); 51 | LUAI_FUNC void luaD_shrinkstack (lua_State *L); 52 | LUAI_FUNC void luaD_inctop (lua_State *L); 53 | 54 | LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode); 55 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); 56 | 57 | #endif 58 | 59 | -------------------------------------------------------------------------------- /lua/src/lfunc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lfunc.h,v 2.15 2015/01/13 15:49:11 roberto Exp $ 3 | ** Auxiliary functions to manipulate prototypes and closures 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lfunc_h 8 | #define lfunc_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | #define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \ 15 | cast(int, sizeof(TValue)*((n)-1))) 16 | 17 | #define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \ 18 | cast(int, sizeof(TValue *)*((n)-1))) 19 | 20 | 21 | /* test whether thread is in 'twups' list */ 22 | #define isintwups(L) (L->twups != L) 23 | 24 | 25 | /* 26 | ** maximum number of upvalues in a closure (both C and Lua). (Value 27 | ** must fit in a VM register.) 28 | */ 29 | #define MAXUPVAL 255 30 | 31 | 32 | /* 33 | ** Upvalues for Lua closures 34 | */ 35 | struct UpVal { 36 | TValue *v; /* points to stack or to its own value */ 37 | lu_mem refcount; /* reference counter */ 38 | union { 39 | struct { /* (when open) */ 40 | UpVal *next; /* linked list */ 41 | int touched; /* mark to avoid cycles with dead threads */ 42 | } open; 43 | TValue value; /* the value (when closed) */ 44 | } u; 45 | }; 46 | 47 | #define upisopen(up) ((up)->v != &(up)->u.value) 48 | 49 | 50 | LUAI_FUNC Proto *luaF_newproto (lua_State *L); 51 | LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems); 52 | LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems); 53 | LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl); 54 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); 55 | LUAI_FUNC void luaF_close (lua_State *L, StkId level); 56 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); 57 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, 58 | int pc); 59 | 60 | 61 | #endif 62 | -------------------------------------------------------------------------------- /lua/src/linit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: linit.c,v 1.39 2016/12/04 20:17:24 roberto Exp $ 3 | ** Initialization of libraries for lua.c and other clients 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #define linit_c 9 | #define LUA_LIB 10 | 11 | /* 12 | ** If you embed Lua in your program and need to open the standard 13 | ** libraries, call luaL_openlibs in your program. If you need a 14 | ** different set of libraries, copy this file to your project and edit 15 | ** it to suit your needs. 16 | ** 17 | ** You can also *preload* libraries, so that a later 'require' can 18 | ** open the library, which is already linked to the application. 19 | ** For that, do the following code: 20 | ** 21 | ** luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); 22 | ** lua_pushcfunction(L, luaopen_modname); 23 | ** lua_setfield(L, -2, modname); 24 | ** lua_pop(L, 1); // remove PRELOAD table 25 | */ 26 | 27 | #include "lprefix.h" 28 | 29 | 30 | #include 31 | 32 | #include "lua.h" 33 | 34 | #include "lualib.h" 35 | #include "lauxlib.h" 36 | 37 | 38 | /* 39 | ** these libs are loaded by lua.c and are readily available to any Lua 40 | ** program 41 | */ 42 | static const luaL_Reg loadedlibs[] = { 43 | {"_G", luaopen_base}, 44 | {LUA_LOADLIBNAME, luaopen_package}, 45 | {LUA_COLIBNAME, luaopen_coroutine}, 46 | {LUA_TABLIBNAME, luaopen_table}, 47 | {LUA_IOLIBNAME, luaopen_io}, 48 | {LUA_OSLIBNAME, luaopen_os}, 49 | {LUA_STRLIBNAME, luaopen_string}, 50 | {LUA_MATHLIBNAME, luaopen_math}, 51 | {LUA_UTF8LIBNAME, luaopen_utf8}, 52 | {LUA_DBLIBNAME, luaopen_debug}, 53 | #if defined(LUA_COMPAT_BITLIB) 54 | {LUA_BITLIBNAME, luaopen_bit32}, 55 | #endif 56 | {NULL, NULL} 57 | }; 58 | 59 | 60 | LUALIB_API void luaL_openlibs (lua_State *L) { 61 | const luaL_Reg *lib; 62 | /* "require" functions from 'loadedlibs' and set results to global table */ 63 | for (lib = loadedlibs; lib->func; lib++) { 64 | luaL_requiref(L, lib->name, lib->func, 1); 65 | lua_pop(L, 1); /* remove lib */ 66 | } 67 | } 68 | 69 | -------------------------------------------------------------------------------- /lua/src/llex.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: llex.h,v 1.79 2016/05/02 14:02:12 roberto Exp $ 3 | ** Lexical Analyzer 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef llex_h 8 | #define llex_h 9 | 10 | #include "lobject.h" 11 | #include "lzio.h" 12 | 13 | 14 | #define FIRST_RESERVED 257 15 | 16 | 17 | #if !defined(LUA_ENV) 18 | #define LUA_ENV "_ENV" 19 | #endif 20 | 21 | 22 | /* 23 | * WARNING: if you change the order of this enumeration, 24 | * grep "ORDER RESERVED" 25 | */ 26 | enum RESERVED { 27 | /* terminal symbols denoted by reserved words */ 28 | TK_AND = FIRST_RESERVED, TK_BREAK, 29 | TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION, 30 | TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, 31 | TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE, 32 | /* other terminal symbols */ 33 | TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, 34 | TK_SHL, TK_SHR, 35 | TK_DBCOLON, TK_EOS, 36 | TK_FLT, TK_INT, TK_NAME, TK_STRING 37 | }; 38 | 39 | /* number of reserved words */ 40 | #define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1)) 41 | 42 | 43 | typedef union { 44 | lua_Number r; 45 | lua_Integer i; 46 | TString *ts; 47 | } SemInfo; /* semantics information */ 48 | 49 | 50 | typedef struct Token { 51 | int token; 52 | SemInfo seminfo; 53 | } Token; 54 | 55 | 56 | /* state of the lexer plus state of the parser when shared by all 57 | functions */ 58 | typedef struct LexState { 59 | int current; /* current character (charint) */ 60 | int linenumber; /* input line counter */ 61 | int lastline; /* line of last token 'consumed' */ 62 | Token t; /* current token */ 63 | Token lookahead; /* look ahead token */ 64 | struct FuncState *fs; /* current function (parser) */ 65 | struct lua_State *L; 66 | ZIO *z; /* input stream */ 67 | Mbuffer *buff; /* buffer for tokens */ 68 | Table *h; /* to avoid collection/reuse strings */ 69 | struct Dyndata *dyd; /* dynamic structures used by the parser */ 70 | TString *source; /* current source name */ 71 | TString *envn; /* environment variable name */ 72 | } LexState; 73 | 74 | 75 | LUAI_FUNC void luaX_init (lua_State *L); 76 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, 77 | TString *source, int firstchar); 78 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l); 79 | LUAI_FUNC void luaX_next (LexState *ls); 80 | LUAI_FUNC int luaX_lookahead (LexState *ls); 81 | LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s); 82 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token); 83 | 84 | 85 | #endif 86 | -------------------------------------------------------------------------------- /lua/src/lmem.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lmem.c,v 1.91 2015/03/06 19:45:54 roberto Exp $ 3 | ** Interface to Memory Manager 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #define lmem_c 8 | #define LUA_CORE 9 | 10 | #include "lprefix.h" 11 | 12 | 13 | #include 14 | 15 | #include "lua.h" 16 | 17 | #include "ldebug.h" 18 | #include "ldo.h" 19 | #include "lgc.h" 20 | #include "lmem.h" 21 | #include "lobject.h" 22 | #include "lstate.h" 23 | 24 | 25 | 26 | /* 27 | ** About the realloc function: 28 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize); 29 | ** ('osize' is the old size, 'nsize' is the new size) 30 | ** 31 | ** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no 32 | ** matter 'x'). 33 | ** 34 | ** * frealloc(ud, p, x, 0) frees the block 'p' 35 | ** (in this specific case, frealloc must return NULL); 36 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing 37 | ** (which is equivalent to free(NULL) in ISO C) 38 | ** 39 | ** frealloc returns NULL if it cannot create or reallocate the area 40 | ** (any reallocation to an equal or smaller size cannot fail!) 41 | */ 42 | 43 | 44 | 45 | #define MINSIZEARRAY 4 46 | 47 | 48 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems, 49 | int limit, const char *what) { 50 | void *newblock; 51 | int newsize; 52 | if (*size >= limit/2) { /* cannot double it? */ 53 | if (*size >= limit) /* cannot grow even a little? */ 54 | luaG_runerror(L, "too many %s (limit is %d)", what, limit); 55 | newsize = limit; /* still have at least one free place */ 56 | } 57 | else { 58 | newsize = (*size)*2; 59 | if (newsize < MINSIZEARRAY) 60 | newsize = MINSIZEARRAY; /* minimum size */ 61 | } 62 | newblock = luaM_reallocv(L, block, *size, newsize, size_elems); 63 | *size = newsize; /* update only when everything else is OK */ 64 | return newblock; 65 | } 66 | 67 | 68 | l_noret luaM_toobig (lua_State *L) { 69 | luaG_runerror(L, "memory allocation error: block too big"); 70 | } 71 | 72 | 73 | 74 | /* 75 | ** generic allocation routine. 76 | */ 77 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 78 | void *newblock; 79 | global_State *g = G(L); 80 | size_t realosize = (block) ? osize : 0; 81 | lua_assert((realosize == 0) == (block == NULL)); 82 | #if defined(HARDMEMTESTS) 83 | if (nsize > realosize && g->gcrunning) 84 | luaC_fullgc(L, 1); /* force a GC whenever possible */ 85 | #endif 86 | newblock = (*g->frealloc)(g->ud, block, osize, nsize); 87 | if (newblock == NULL && nsize > 0) { 88 | lua_assert(nsize > realosize); /* cannot fail when shrinking a block */ 89 | if (g->version) { /* is state fully built? */ 90 | luaC_fullgc(L, 1); /* try to free some memory... */ 91 | newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */ 92 | } 93 | if (newblock == NULL) 94 | luaD_throw(L, LUA_ERRMEM); 95 | } 96 | lua_assert((nsize == 0) == (newblock == NULL)); 97 | g->GCdebt = (g->GCdebt + nsize) - realosize; 98 | return newblock; 99 | } 100 | 101 | -------------------------------------------------------------------------------- /lua/src/lmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lmem.h,v 1.43 2014/12/19 17:26:14 roberto Exp $ 3 | ** Interface to Memory Manager 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lmem_h 8 | #define lmem_h 9 | 10 | 11 | #include 12 | 13 | #include "llimits.h" 14 | #include "lua.h" 15 | 16 | 17 | /* 18 | ** This macro reallocs a vector 'b' from 'on' to 'n' elements, where 19 | ** each element has size 'e'. In case of arithmetic overflow of the 20 | ** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because 21 | ** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e). 22 | ** 23 | ** (The macro is somewhat complex to avoid warnings: The 'sizeof' 24 | ** comparison avoids a runtime comparison when overflow cannot occur. 25 | ** The compiler should be able to optimize the real test by itself, but 26 | ** when it does it, it may give a warning about "comparison is always 27 | ** false due to limited range of data type"; the +1 tricks the compiler, 28 | ** avoiding this warning but also this optimization.) 29 | */ 30 | #define luaM_reallocv(L,b,on,n,e) \ 31 | (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \ 32 | ? luaM_toobig(L) : cast_void(0)) , \ 33 | luaM_realloc_(L, (b), (on)*(e), (n)*(e))) 34 | 35 | /* 36 | ** Arrays of chars do not need any test 37 | */ 38 | #define luaM_reallocvchar(L,b,on,n) \ 39 | cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) 40 | 41 | #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) 42 | #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) 43 | #define luaM_freearray(L, b, n) luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0) 44 | 45 | #define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s)) 46 | #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) 47 | #define luaM_newvector(L,n,t) \ 48 | cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t))) 49 | 50 | #define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s)) 51 | 52 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \ 53 | if ((nelems)+1 > (size)) \ 54 | ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e))) 55 | 56 | #define luaM_reallocvector(L, v,oldn,n,t) \ 57 | ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t)))) 58 | 59 | LUAI_FUNC l_noret luaM_toobig (lua_State *L); 60 | 61 | /* not to be called directly */ 62 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, 63 | size_t size); 64 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size, 65 | size_t size_elem, int limit, 66 | const char *what); 67 | 68 | #endif 69 | 70 | -------------------------------------------------------------------------------- /lua/src/lprefix.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lprefix.h,v 1.2 2014/12/29 16:54:13 roberto Exp $ 3 | ** Definitions for Lua code that must come before any other header file 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lprefix_h 8 | #define lprefix_h 9 | 10 | 11 | /* 12 | ** Allows POSIX/XSI stuff 13 | */ 14 | #if !defined(LUA_USE_C89) /* { */ 15 | 16 | #if !defined(_XOPEN_SOURCE) 17 | #define _XOPEN_SOURCE 600 18 | #elif _XOPEN_SOURCE == 0 19 | #undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */ 20 | #endif 21 | 22 | /* 23 | ** Allows manipulation of large files in gcc and some other compilers 24 | */ 25 | #if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS) 26 | #define _LARGEFILE_SOURCE 1 27 | #define _FILE_OFFSET_BITS 64 28 | #endif 29 | 30 | #endif /* } */ 31 | 32 | 33 | /* 34 | ** Windows stuff 35 | */ 36 | #if defined(_WIN32) /* { */ 37 | 38 | #if !defined(_CRT_SECURE_NO_WARNINGS) 39 | #define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */ 40 | #endif 41 | 42 | #endif /* } */ 43 | 44 | #endif 45 | 46 | -------------------------------------------------------------------------------- /lua/src/lstring.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lstring.h,v 1.61 2015/11/03 15:36:01 roberto Exp $ 3 | ** String table (keep all strings handled by Lua) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lstring_h 8 | #define lstring_h 9 | 10 | #include "lgc.h" 11 | #include "lobject.h" 12 | #include "lstate.h" 13 | 14 | 15 | #define sizelstring(l) (sizeof(union UTString) + ((l) + 1) * sizeof(char)) 16 | 17 | #define sizeludata(l) (sizeof(union UUdata) + (l)) 18 | #define sizeudata(u) sizeludata((u)->len) 19 | 20 | #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ 21 | (sizeof(s)/sizeof(char))-1)) 22 | 23 | 24 | /* 25 | ** test whether a string is a reserved word 26 | */ 27 | #define isreserved(s) ((s)->tt == LUA_TSHRSTR && (s)->extra > 0) 28 | 29 | 30 | /* 31 | ** equality for short strings, which are always internalized 32 | */ 33 | #define eqshrstr(a,b) check_exp((a)->tt == LUA_TSHRSTR, (a) == (b)) 34 | 35 | 36 | LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); 37 | LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts); 38 | LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); 39 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize); 40 | LUAI_FUNC void luaS_clearcache (global_State *g); 41 | LUAI_FUNC void luaS_init (lua_State *L); 42 | LUAI_FUNC void luaS_remove (lua_State *L, TString *ts); 43 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s); 44 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); 45 | LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); 46 | LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l); 47 | 48 | 49 | #endif 50 | -------------------------------------------------------------------------------- /lua/src/ltable.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ltable.h,v 2.23 2016/12/22 13:08:50 roberto Exp $ 3 | ** Lua tables (hash) 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ltable_h 8 | #define ltable_h 9 | 10 | #include "lobject.h" 11 | 12 | 13 | #define gnode(t,i) (&(t)->node[i]) 14 | #define gval(n) (&(n)->i_val) 15 | #define gnext(n) ((n)->i_key.nk.next) 16 | 17 | 18 | /* 'const' to avoid wrong writings that can mess up field 'next' */ 19 | #define gkey(n) cast(const TValue*, (&(n)->i_key.tvk)) 20 | 21 | /* 22 | ** writable version of 'gkey'; allows updates to individual fields, 23 | ** but not to the whole (which has incompatible type) 24 | */ 25 | #define wgkey(n) (&(n)->i_key.nk) 26 | 27 | #define invalidateTMcache(t) ((t)->flags = 0) 28 | 29 | 30 | /* true when 't' is using 'dummynode' as its hash part */ 31 | #define isdummy(t) ((t)->lastfree == NULL) 32 | 33 | 34 | /* allocated size for hash nodes */ 35 | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) 36 | 37 | 38 | /* returns the key, given the value of a table entry */ 39 | #define keyfromval(v) \ 40 | (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val)))) 41 | 42 | 43 | LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key); 44 | LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key, 45 | TValue *value); 46 | LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key); 47 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); 48 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); 49 | LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); 50 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); 51 | LUAI_FUNC Table *luaH_new (lua_State *L); 52 | LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize, 53 | unsigned int nhsize); 54 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize); 55 | LUAI_FUNC void luaH_free (lua_State *L, Table *t); 56 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); 57 | LUAI_FUNC int luaH_getn (Table *t); 58 | 59 | 60 | #if defined(LUA_DEBUG) 61 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); 62 | LUAI_FUNC int luaH_isdummy (const Table *t); 63 | #endif 64 | 65 | 66 | #endif 67 | -------------------------------------------------------------------------------- /lua/src/ltm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: ltm.h,v 2.22 2016/02/26 19:20:15 roberto Exp $ 3 | ** Tag methods 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef ltm_h 8 | #define ltm_h 9 | 10 | 11 | #include "lobject.h" 12 | 13 | 14 | /* 15 | * WARNING: if you change the order of this enumeration, 16 | * grep "ORDER TM" and "ORDER OP" 17 | */ 18 | typedef enum { 19 | TM_INDEX, 20 | TM_NEWINDEX, 21 | TM_GC, 22 | TM_MODE, 23 | TM_LEN, 24 | TM_EQ, /* last tag method with fast access */ 25 | TM_ADD, 26 | TM_SUB, 27 | TM_MUL, 28 | TM_MOD, 29 | TM_POW, 30 | TM_DIV, 31 | TM_IDIV, 32 | TM_BAND, 33 | TM_BOR, 34 | TM_BXOR, 35 | TM_SHL, 36 | TM_SHR, 37 | TM_UNM, 38 | TM_BNOT, 39 | TM_LT, 40 | TM_LE, 41 | TM_CONCAT, 42 | TM_CALL, 43 | TM_N /* number of elements in the enum */ 44 | } TMS; 45 | 46 | 47 | 48 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \ 49 | ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) 50 | 51 | #define fasttm(l,et,e) gfasttm(G(l), et, e) 52 | 53 | #define ttypename(x) luaT_typenames_[(x) + 1] 54 | 55 | LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS]; 56 | 57 | 58 | LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o); 59 | 60 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); 61 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, 62 | TMS event); 63 | LUAI_FUNC void luaT_init (lua_State *L); 64 | 65 | LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, 66 | const TValue *p2, TValue *p3, int hasres); 67 | LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2, 68 | StkId res, TMS event); 69 | LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2, 70 | StkId res, TMS event); 71 | LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1, 72 | const TValue *p2, TMS event); 73 | 74 | 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /lua/src/lua.hpp: -------------------------------------------------------------------------------- 1 | // lua.hpp 2 | // Lua header files for C++ 3 | // <> not supplied automatically because Lua also compiles as C++ 4 | 5 | extern "C" { 6 | #include "lua.h" 7 | #include "lualib.h" 8 | #include "lauxlib.h" 9 | } 10 | -------------------------------------------------------------------------------- /lua/src/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lualib.h,v 1.45 2017/01/12 17:14:26 roberto Exp $ 3 | ** Lua standard libraries 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lualib_h 9 | #define lualib_h 10 | 11 | #include "lua.h" 12 | 13 | 14 | /* version suffix for environment variable names */ 15 | #define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR 16 | 17 | 18 | LUAMOD_API int (luaopen_base) (lua_State *L); 19 | 20 | #define LUA_COLIBNAME "coroutine" 21 | LUAMOD_API int (luaopen_coroutine) (lua_State *L); 22 | 23 | #define LUA_TABLIBNAME "table" 24 | LUAMOD_API int (luaopen_table) (lua_State *L); 25 | 26 | #define LUA_IOLIBNAME "io" 27 | LUAMOD_API int (luaopen_io) (lua_State *L); 28 | 29 | #define LUA_OSLIBNAME "os" 30 | LUAMOD_API int (luaopen_os) (lua_State *L); 31 | 32 | #define LUA_STRLIBNAME "string" 33 | LUAMOD_API int (luaopen_string) (lua_State *L); 34 | 35 | #define LUA_UTF8LIBNAME "utf8" 36 | LUAMOD_API int (luaopen_utf8) (lua_State *L); 37 | 38 | #define LUA_BITLIBNAME "bit32" 39 | LUAMOD_API int (luaopen_bit32) (lua_State *L); 40 | 41 | #define LUA_MATHLIBNAME "math" 42 | LUAMOD_API int (luaopen_math) (lua_State *L); 43 | 44 | #define LUA_DBLIBNAME "debug" 45 | LUAMOD_API int (luaopen_debug) (lua_State *L); 46 | 47 | #define LUA_LOADLIBNAME "package" 48 | LUAMOD_API int (luaopen_package) (lua_State *L); 49 | 50 | 51 | /* open all previous libraries */ 52 | LUALIB_API void (luaL_openlibs) (lua_State *L); 53 | 54 | 55 | 56 | #if !defined(lua_assert) 57 | #define lua_assert(x) ((void)0) 58 | #endif 59 | 60 | 61 | #endif 62 | -------------------------------------------------------------------------------- /lua/src/lundump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lundump.h,v 1.45 2015/09/08 15:41:05 roberto Exp $ 3 | ** load precompiled Lua chunks 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lundump_h 8 | #define lundump_h 9 | 10 | #include "llimits.h" 11 | #include "lobject.h" 12 | #include "lzio.h" 13 | 14 | 15 | /* data to catch conversion errors */ 16 | #define LUAC_DATA "\x19\x93\r\n\x1a\n" 17 | 18 | #define LUAC_INT 0x5678 19 | #define LUAC_NUM cast_num(370.5) 20 | 21 | #define MYINT(s) (s[0]-'0') 22 | #define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)) 23 | #define LUAC_FORMAT 0 /* this is the official format */ 24 | 25 | /* load one chunk; from lundump.c */ 26 | LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name); 27 | 28 | /* dump one chunk; from ldump.c */ 29 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, 30 | void* data, int strip); 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /lua/src/lzio.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lzio.c,v 1.37 2015/09/08 15:41:05 roberto Exp $ 3 | ** Buffered streams 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #define lzio_c 8 | #define LUA_CORE 9 | 10 | #include "lprefix.h" 11 | 12 | 13 | #include 14 | 15 | #include "lua.h" 16 | 17 | #include "llimits.h" 18 | #include "lmem.h" 19 | #include "lstate.h" 20 | #include "lzio.h" 21 | 22 | 23 | int luaZ_fill (ZIO *z) { 24 | size_t size; 25 | lua_State *L = z->L; 26 | const char *buff; 27 | lua_unlock(L); 28 | buff = z->reader(L, z->data, &size); 29 | lua_lock(L); 30 | if (buff == NULL || size == 0) 31 | return EOZ; 32 | z->n = size - 1; /* discount char being returned */ 33 | z->p = buff; 34 | return cast_uchar(*(z->p++)); 35 | } 36 | 37 | 38 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39 | z->L = L; 40 | z->reader = reader; 41 | z->data = data; 42 | z->n = 0; 43 | z->p = NULL; 44 | } 45 | 46 | 47 | /* --------------------------------------------------------------- read --- */ 48 | size_t luaZ_read (ZIO *z, void *b, size_t n) { 49 | while (n) { 50 | size_t m; 51 | if (z->n == 0) { /* no bytes in buffer? */ 52 | if (luaZ_fill(z) == EOZ) /* try to read more */ 53 | return n; /* no more input; return number of missing bytes */ 54 | else { 55 | z->n++; /* luaZ_fill consumed first byte; put it back */ 56 | z->p--; 57 | } 58 | } 59 | m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ 60 | memcpy(b, z->p, m); 61 | z->n -= m; 62 | z->p += m; 63 | b = (char *)b + m; 64 | n -= m; 65 | } 66 | return 0; 67 | } 68 | 69 | -------------------------------------------------------------------------------- /lua/src/lzio.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id: lzio.h,v 1.31 2015/09/08 15:41:05 roberto Exp $ 3 | ** Buffered streams 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #ifndef lzio_h 9 | #define lzio_h 10 | 11 | #include "lua.h" 12 | 13 | #include "lmem.h" 14 | 15 | 16 | #define EOZ (-1) /* end of stream */ 17 | 18 | typedef struct Zio ZIO; 19 | 20 | #define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) 21 | 22 | 23 | typedef struct Mbuffer { 24 | char *buffer; 25 | size_t n; 26 | size_t buffsize; 27 | } Mbuffer; 28 | 29 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) 30 | 31 | #define luaZ_buffer(buff) ((buff)->buffer) 32 | #define luaZ_sizebuffer(buff) ((buff)->buffsize) 33 | #define luaZ_bufflen(buff) ((buff)->n) 34 | 35 | #define luaZ_buffremove(buff,i) ((buff)->n -= (i)) 36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0) 37 | 38 | 39 | #define luaZ_resizebuffer(L, buff, size) \ 40 | ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ 41 | (buff)->buffsize, size), \ 42 | (buff)->buffsize = size) 43 | 44 | #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) 45 | 46 | 47 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, 48 | void *data); 49 | LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */ 50 | 51 | 52 | 53 | /* --------- Private Part ------------------ */ 54 | 55 | struct Zio { 56 | size_t n; /* bytes still unread */ 57 | const char *p; /* current position in buffer */ 58 | lua_Reader reader; /* reader function */ 59 | void *data; /* additional data */ 60 | lua_State *L; /* Lua state (for reader) */ 61 | }; 62 | 63 | 64 | LUAI_FUNC int luaZ_fill (ZIO *z); 65 | 66 | #endif 67 | -------------------------------------------------------------------------------- /scripts/PullSource.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # @file PullSource.sh 3 | # Released to the public domain. 4 | 5 | # Script to update Lexilla, Scintilla, and SciTE from remote repository. 6 | # May fail for more complex local states. 7 | 8 | ( 9 | 10 | cd $(dirname $0)/../.. 11 | 12 | ( 13 | cd lexilla || exit 14 | git pull --rebase 15 | ) 16 | 17 | hg pull -u -R scintilla 18 | hg pull -u -R scite 19 | 20 | ) 21 | -------------------------------------------------------------------------------- /scripts/TagRelease.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # TagRelease.py - implemented 2023 by Neil Hodgson neilh@scintilla.org 3 | # Released to the public domain. 4 | 5 | # Tag Lexilla, Scintilla, and SciTE with version numbers. 6 | # Requires Python 3.6 or later 7 | 8 | import os, pathlib, subprocess, sys 9 | 10 | sciteBase = pathlib.Path(__file__).resolve().parent.parent 11 | baseDirectory = sciteBase.parent 12 | sciDirectory = baseDirectory / "scintilla" 13 | lexDirectory = baseDirectory / "lexilla" 14 | 15 | sys.path.append(str(sciDirectory / "scripts")) 16 | sys.path.append(str(lexDirectory / "scripts")) 17 | 18 | import ScintillaData 19 | import LexillaData 20 | 21 | def DashedVersion(version): 22 | return version[0:-2] + '-' + version[-2] + '-' + version[-1] 23 | 24 | def tagOne(project, version): 25 | os.chdir(project) 26 | releaseTag = "rel-" + DashedVersion(version) 27 | if project == "lexilla": 28 | command = f"git tag {releaseTag}" 29 | else: 30 | command = f"hg tag {releaseTag}" 31 | print(command) 32 | subprocess.call(command, shell=True) 33 | os.chdir("..") 34 | 35 | def TagAll(): 36 | os.chdir(baseDirectory) 37 | sci = ScintillaData.ScintillaData(sciDirectory) 38 | lex = LexillaData.LexillaData(lexDirectory) 39 | sciteVersion = (sciteBase / "version.txt").read_text().strip() 40 | 41 | tagOne("lexilla", lex.version) 42 | tagOne("scintilla", sci.version) 43 | tagOne("scite", sciteVersion) 44 | 45 | TagAll() 46 | -------------------------------------------------------------------------------- /scripts/UpdateSizeInDocs.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # UpdateSizeInDocs.py 3 | # Update the documented sizes of downloads to match the current release. 4 | # Uses local build directory (../../../arc/upload) on Neil's machine 5 | # so must be modified for other installations. 6 | # Implemented 2019 by Neil Hodgson neilh@scintilla.org 7 | # Requires Python 3.6 or later 8 | 9 | import pathlib 10 | 11 | downloadHome = "https://www.scintilla.org/" 12 | 13 | def ExtractFileName(s): 14 | pre, _quote, rest = s.partition('"') 15 | url, _quote, rest = rest.partition('"') 16 | _domain, _slash, name = url.rpartition('/') 17 | return name 18 | 19 | def FileSizeInMB(filePath): 20 | size = filePath.stat().st_size 21 | sizeInM = size / 1024 / 1024 22 | roundToNearest = round(sizeInM * 10) / 10 23 | return str(roundToNearest) + "M" 24 | 25 | def FileSizesInDirectory(base): 26 | return {p.name : FileSizeInMB(p) for p in base.glob("*")} 27 | 28 | def UpdateFileSizes(scriptsPath): 29 | sciteRoot = scriptsPath.parent 30 | scintillaRoot = sciteRoot.parent / "scintilla" 31 | lexillaRoot = sciteRoot.parent / "lexilla" 32 | releaseRoot = sciteRoot.parent.parent / "arc" 33 | 34 | uploadDocs = [ 35 | sciteRoot / "doc" / "SciTEDownload.html", 36 | scintillaRoot / "doc" / "ScintillaDownload.html", 37 | lexillaRoot / "doc" / "LexillaDownload.html", 38 | ] 39 | 40 | version = (sciteRoot / "version.txt").read_text().strip() 41 | currentRelease = releaseRoot / ("upload" + version) 42 | fileSizes = FileSizesInDirectory(currentRelease) 43 | if not fileSizes: 44 | print("No files in", currentRelease) 45 | 46 | for docFileName in uploadDocs: 47 | outLines = "" 48 | changes = False 49 | with docFileName.open() as docFile: 50 | for line in docFile: 51 | if downloadHome in line and '(' in line and ')' in line: 52 | fileName = ExtractFileName(line) 53 | if fileName in fileSizes: 54 | pre, bracket, rest = line.partition('(') 55 | size, rbracket, end = rest.partition(')') 56 | if size != fileSizes[fileName]: 57 | line = pre + bracket + fileSizes[fileName] + rbracket + end 58 | changes = True 59 | print(f"{size} -> {fileSizes[fileName]} {fileName}") 60 | outLines += line 61 | if changes: 62 | print("Updating", docFileName) 63 | docFileName.write_text(outLines) 64 | 65 | if __name__=="__main__": 66 | UpdateFileSizes(pathlib.Path(__file__).resolve().parent) 67 | -------------------------------------------------------------------------------- /scripts/archive.sh: -------------------------------------------------------------------------------- 1 | # Up to parent directory of scite 2 | cd ../.. 3 | 4 | # Archive Lexilla, Scintilla, and SciTE to scite-clean 5 | rm -rf scite-clean 6 | git clone lexilla scite-clean/lexilla 7 | rm -rf scite-clean/lexilla/.git 8 | hg archive --repository scintilla scite-clean/scintilla 9 | hg archive --repository scite scite-clean/scite 10 | 11 | # tar lexilla, scintillas and scite into scite.tgz 12 | rm -f scite.tgz 13 | ( 14 | cd scite-clean || exit 15 | tar -czf ../scite.tgz lexilla scintilla scite 16 | ) 17 | 18 | # Remove temporary directory 19 | rm -rf scite-clean 20 | -------------------------------------------------------------------------------- /scripts/ba: -------------------------------------------------------------------------------- 1 | sci_base=`pwd` 2 | cd $sci_base/scintilla/gtk 3 | make $* 4 | cd $sci_base/scite/gtk 5 | make $* 6 | #make install $* 7 | cd $sci_base/scintilla 8 | sh tgzsrc 9 | cd $sci_base/scite 10 | sh tgzsrc 11 | cd $sci_base/scite 12 | sh tgzgscite 13 | 14 | -------------------------------------------------------------------------------- /scripts/clearboth.bat: -------------------------------------------------------------------------------- 1 | @rem clearboth.bat - script to clear both scintilla and scite 2 | @rem directory trees of all compiler output files. 3 | @rem Current directory must be parent of scintilla and scite before running. 4 | @pushd lexilla 5 | @call delbin 6 | @popd 7 | @pushd scintilla 8 | @call delbin 9 | @popd 10 | @pushd scite 11 | @call delbin 12 | @popd 13 | -------------------------------------------------------------------------------- /scripts/commandsdoc.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | # Requires Python 3.6 or later 4 | 5 | from __future__ import with_statement 6 | 7 | import os, sys 8 | 9 | scintillaDirectory = os.path.join("..", "..", "scintilla") 10 | scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts") 11 | sys.path.append(scintillaScriptsDirectory) 12 | import Face 13 | 14 | def head(s): 15 | return "%s" % s 16 | 17 | def cell(s): 18 | return "%s" % s 19 | 20 | def faceFeatures(out): 21 | out.write("

Scintilla key commands

\n") 22 | out.write("\n") 23 | out.write("%s%s%s\n" % (head("Command"), head("Name"), head("Explanation"))) 24 | face = Face.Face() 25 | face.ReadFromFile(os.path.join(scintillaDirectory, "include", "Scintilla.iface")) 26 | texts = [] 27 | for name in face.features: 28 | #~ print name 29 | f = face.features[name] 30 | if f["FeatureType"] == "fun" and \ 31 | f["ReturnType"] == "void" and \ 32 | not (f["Param1Type"] or f["Param2Type"]): 33 | texts.append([name, f["Value"], " ".join(f["Comment"])]) 34 | texts.sort() 35 | for t in texts: 36 | out.write("%s%s%s\n" % (cell(t[1]), cell(t[0]), cell(t[2]))) 37 | out.write("
\n") 38 | 39 | def menuFeatures(out): 40 | out.write("

SciTE menu commands

\n") 41 | out.write("\n") 42 | out.write("%s%s\n" % (head("Command"), head("Menu text"))) 43 | with open(os.path.join("..", "win32", "SciTERes.rc"), "rt") as f: 44 | for line in f: 45 | s = line.strip() 46 | if s.startswith("MENUITEM") and "SEPARATOR" not in s: 47 | s = s.replace("MENUITEM", "").strip() 48 | text, symbol = s.split('",', 1) 49 | symbol = symbol.strip() 50 | text = text[1:].replace("&", "").replace("...", "") 51 | if "\\t" in text: 52 | text = text.split("\\t",1)[0] 53 | if text: 54 | out.write("\n" % (symbol, text)) 55 | out.write("
%s%s
\n") 56 | 57 | startFile = """ 58 | 59 | 61 | 62 | 63 | 69 | 70 | """ 71 | 72 | def RegenerateAll(): 73 | with open(os.path.join("..", "doc", "CommandValues.html"), "w") as out: 74 | out.write(startFile) 75 | menuFeatures(out) 76 | faceFeatures(out) 77 | out.write("\n\n") 78 | 79 | if __name__ == "__main__": 80 | RegenerateAll() 81 | -------------------------------------------------------------------------------- /scripts/makerpms.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # makerpms.py 3 | # Copy files all over the place build RPMs and copy to top level directory 4 | # Contributed file - not tested before releases made. 5 | 6 | import os 7 | import shutil 8 | srcRoot = "../../" 9 | rpmRoot = "/usr/src/redhat/SOURCES/" 10 | rpmBin = "/usr/src/redhat/RPMS/i386/" 11 | rpmSource = "/usr/src/redhat/SRPMS/" 12 | 13 | verFileName = srcRoot + "scintilla/version.txt" 14 | vers = open(verFileName) 15 | #139 16 | vFull = vers.read().strip() 17 | vers.close() 18 | 19 | #1.39 20 | vPoint = vFull[0] + "." + vFull[1:] 21 | 22 | #1, 3, 9, 0 23 | vComma = vFull[0] + ", " + vFull[1] + ", " + vFull[2] + ", 0" 24 | 25 | print("[ %s | %s | %s ]" % (vFull, vPoint, vComma)) 26 | 27 | tgzV = "scite" + vFull + ".tgz" 28 | tgzFileName = srcRoot + "scite.tgz" 29 | tgzVFileName = srcRoot + tgzV 30 | 31 | print("[ %s | %s ]" % (tgzFileName, tgzVFileName)) 32 | 33 | if not os.access(tgzFileName, os.F_OK): 34 | print("Base file '" + tgzFileName + "' does not exist.") 35 | else: 36 | shutil.copyfile(tgzFileName, tgzVFileName) 37 | os.unlink(tgzFileName) 38 | 39 | rpmVFileName = rpmRoot + tgzV 40 | 41 | shutil.copyfile(tgzVFileName, rpmVFileName) 42 | 43 | # Run the rpm build command 44 | os.system("rpm -ba scite.spec") 45 | 46 | rpmB = "scite-" + vPoint + "-1.i386.rpm" 47 | shutil.copyfile(rpmBin + rpmB, srcRoot + rpmB) 48 | rpmS = "scite-" + vPoint + "-1.src.rpm" 49 | shutil.copyfile(rpmSource + rpmS, srcRoot + rpmS) 50 | 51 | -------------------------------------------------------------------------------- /src/Cookie.cxx: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file Cookie.cxx 3 | ** Examine start of files for coding cookies and type information. 4 | **/ 5 | // Copyright 2011 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #include "GUI.h" 19 | 20 | #include "StringHelpers.h" 21 | #include "Cookie.h" 22 | 23 | std::string_view ExtractLine(std::string_view sv) noexcept { 24 | std::string_view remainder = sv; 25 | while ((remainder.length() > 0) && (remainder[0] != '\r') && (remainder[0] != '\n')) { 26 | remainder.remove_prefix(1); 27 | } 28 | if ((remainder.length() > 1) && (remainder[0] == '\r') && (remainder[1] == '\n')) { 29 | remainder.remove_prefix(1); 30 | } 31 | if (remainder.length() > 0) { 32 | remainder.remove_prefix(1); 33 | } 34 | sv.remove_suffix(remainder.length()); 35 | return sv; 36 | } 37 | 38 | namespace { 39 | 40 | constexpr std::string_view codingCookie("coding"); 41 | constexpr std::string_view utf8Name("utf-8"); 42 | 43 | constexpr bool isEncodingChar(char ch) noexcept { 44 | return (ch == '_') || (ch == '-') || (ch == '.') || 45 | (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || 46 | (ch >= '0' && ch <= '9'); 47 | } 48 | 49 | constexpr bool isSpaceChar(char ch) noexcept { 50 | return (ch == ' ') || (ch == '\t'); 51 | } 52 | 53 | UniMode CookieValue(std::string_view s) noexcept { 54 | const size_t posCoding = s.find(codingCookie); 55 | if (posCoding != std::string_view::npos) { 56 | s.remove_prefix(posCoding + codingCookie.length()); 57 | if ((s.length() > 0) && ((s[0] == ':') || (s[0] == '='))) { 58 | s.remove_prefix(1); 59 | if ((s.length() > 0) && ((s[0] == '\"') || (s[0] == '\''))) { 60 | s.remove_prefix(1); 61 | } 62 | while ((s.length() > 0) && (isSpaceChar(s[0]))) { 63 | s.remove_prefix(1); 64 | } 65 | size_t endCoding = 0; 66 | while ((endCoding < s.length()) && 67 | (isEncodingChar(s[endCoding]))) { 68 | endCoding++; 69 | } 70 | s.remove_suffix(s.length() - endCoding); 71 | if (EqualCaseInsensitive(s, utf8Name)) { 72 | return UniMode::cookie; 73 | } 74 | } 75 | } 76 | return UniMode::uni8Bit; 77 | } 78 | 79 | } 80 | 81 | UniMode CodingCookieValue(std::string_view sv) noexcept { 82 | const std::string_view l1 = ExtractLine(sv); 83 | UniMode unicodeMode = CookieValue(l1); 84 | if (unicodeMode == UniMode::uni8Bit) { 85 | sv.remove_prefix(l1.length()); 86 | const std::string_view l2 = ExtractLine(sv); 87 | unicodeMode = CookieValue(l2); 88 | } 89 | return unicodeMode; 90 | } 91 | 92 | -------------------------------------------------------------------------------- /src/Cookie.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file Cookie.h 3 | ** Examine start of files for coding cookies and type information. 4 | **/ 5 | // Copyright 2011 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef COOKIE_H 9 | #define COOKIE_H 10 | 11 | // Related to Utf8_16::encodingType but with additional values at end 12 | enum class UniMode { 13 | uni8Bit = 0, uni16BE = 1, uni16LE = 2, utf8 = 3, 14 | cookie = 4 15 | }; 16 | 17 | std::string_view ExtractLine(std::string_view sv) noexcept; 18 | UniMode CodingCookieValue(std::string_view sv) noexcept; 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /src/EditorConfig.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file EditorConfig.h 3 | ** Read and interpret settings files in the EditorConfig format. 4 | **/ 5 | // Copyright 2018 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef EDITORCONFIG_H 9 | #define EDITORCONFIG_H 10 | 11 | class FilePath; 12 | 13 | class IEditorConfig { 14 | public: 15 | virtual ~IEditorConfig() = default; 16 | virtual void ReadFromDirectory(const FilePath &dirStart) = 0; 17 | virtual std::map MapFromAbsolutePath(const FilePath &absolutePath) const = 0; 18 | virtual void Clear() = 0; 19 | static std::unique_ptr Create(); 20 | }; 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /src/Embedded.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/src/Embedded.properties -------------------------------------------------------------------------------- /src/FilePath.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file FilePath.h 3 | ** Definition of platform independent base class of editor. 4 | **/ 5 | // Copyright 1998-2005 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef FILEPATH_H 9 | #define FILEPATH_H 10 | 11 | extern const GUI::gui_char pathSepString[]; 12 | extern const GUI::gui_char listSepString[]; 13 | extern const GUI::gui_char configFileVisibilityString[]; 14 | extern const GUI::gui_char fileRead[]; 15 | extern const GUI::gui_char fileWrite[]; 16 | 17 | class FilePath; 18 | 19 | typedef std::vector FilePathSet; 20 | 21 | struct FileCloser { 22 | // Called by unique_ptr to close the file 23 | void operator()(FILE *file) noexcept { 24 | if (file) { 25 | fclose(file); 26 | } 27 | } 28 | }; 29 | 30 | using FileHolder = std::unique_ptr; 31 | 32 | class FilePath { 33 | GUI::gui_string fileName; 34 | public: 35 | FilePath() noexcept; 36 | FilePath(const GUI::gui_char *fileName_); 37 | FilePath(const GUI::gui_string_view fileName_); 38 | FilePath(const GUI::gui_string &fileName_); 39 | FilePath(FilePath const &directory, FilePath const &name); 40 | FilePath(FilePath const &) = default; 41 | FilePath(FilePath &&) noexcept = default; 42 | FilePath &operator=(FilePath const &) = default; 43 | FilePath &operator=(FilePath &&) noexcept = default; 44 | virtual ~FilePath() = default; 45 | 46 | void Set(const GUI::gui_char *fileName_); 47 | void Set(FilePath const &other); 48 | void Set(FilePath const &directory, FilePath const &name); 49 | void SetDirectory(FilePath const &directory); 50 | virtual void Init() noexcept; 51 | [[nodiscard]]bool SameNameAs(const FilePath &other) const noexcept; 52 | bool operator==(const FilePath &other) const noexcept; 53 | bool operator<(const FilePath &other) const noexcept; 54 | bool IsSet() const noexcept; 55 | bool IsUntitled() const noexcept; 56 | bool IsAbsolute() const noexcept; 57 | bool IsRoot() const noexcept; 58 | static int RootLength() noexcept; 59 | const GUI::gui_char *AsInternal() const noexcept; 60 | std::string AsUTF8() const; 61 | FilePath Name() const; 62 | FilePath BaseName() const; 63 | FilePath Extension() const; 64 | FilePath Directory() const; 65 | void FixName(); 66 | FilePath AbsolutePath() const; 67 | FilePath NormalizePath() const; 68 | GUI::gui_string RelativePathTo(const FilePath &filePath) const; 69 | static FilePath GetWorkingDirectory(); 70 | bool SetWorkingDirectory() const noexcept; 71 | static FilePath UserHomeDirectory(); 72 | void List(FilePathSet &directories, FilePathSet &files) const; 73 | FILE *Open(const GUI::gui_char *mode) const noexcept; 74 | std::string Read() const; 75 | void Remove() const noexcept; 76 | time_t ModifiedTime() const noexcept; 77 | long long GetFileLength() const noexcept; 78 | bool Exists() const noexcept; 79 | bool IsDirectory() const noexcept; 80 | bool Matches(GUI::gui_string_view pattern) const; 81 | static bool CaseSensitive() noexcept; 82 | }; 83 | 84 | std::string CommandExecute(const GUI::gui_char *command, const GUI::gui_char *directoryForRun); 85 | 86 | #endif 87 | -------------------------------------------------------------------------------- /src/FileWorker.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file FileWorker.h 3 | ** Definition of classes to perform background file tasks as threads. 4 | **/ 5 | // Copyright 2011 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef FILEWORKER_H 9 | #define FILEWORKER_H 10 | 11 | /// Base size of file I/O operations. 12 | constexpr size_t blockSize = 128 * 1024; 13 | 14 | struct FileWorker : public Worker { 15 | WorkerListener *pListener; 16 | FilePath path; 17 | size_t size; 18 | int err; 19 | FILE *fp; 20 | GUI::ElapsedTime et; 21 | int sleepTime; 22 | double nextProgress; 23 | 24 | FileWorker(WorkerListener *pListener_, const FilePath &path_, size_t size_, FILE *fp_); 25 | ~FileWorker() noexcept override; 26 | virtual double Duration() noexcept; 27 | void Cancel() noexcept override { 28 | Worker::Cancel(); 29 | } 30 | virtual bool IsLoading() const noexcept = 0; 31 | }; 32 | 33 | class FileLoader : public FileWorker { 34 | public: 35 | Scintilla::ILoader *pLoader; 36 | size_t readSoFar; 37 | UniMode unicodeMode; 38 | 39 | FileLoader(WorkerListener *pListener_, Scintilla::ILoader *pLoader_, const FilePath &path_, size_t size_, FILE *fp_); 40 | void Execute() noexcept override; 41 | void Cancel() noexcept override; 42 | bool IsLoading() const noexcept override { 43 | return true; 44 | } 45 | }; 46 | 47 | class FileStorer : public FileWorker { 48 | public: 49 | const char *documentBytes; 50 | size_t writtenSoFar; 51 | UniMode unicodeMode; 52 | bool visibleProgress; 53 | std::unique_ptr convert; 54 | 55 | FileStorer(WorkerListener *pListener_, std::string_view bytes_, const FilePath &path_, 56 | FILE *fp_, UniMode unicodeMode_, bool visibleProgress_); 57 | void Execute() noexcept override; 58 | void Cancel() noexcept override; 59 | bool IsLoading() const noexcept override { 60 | return false; 61 | } 62 | }; 63 | 64 | enum { 65 | WORK_FILEREAD = 1, 66 | WORK_FILEWRITTEN = 2, 67 | WORK_FILEPROGRESS = 3, 68 | WORK_PLATFORM = 100 69 | }; 70 | 71 | #endif 72 | -------------------------------------------------------------------------------- /src/IFaceTable.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file IFaceTable.h 3 | ** SciTE iface function and constant descriptors. 4 | **/ 5 | // Copyright 1998-2004 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef IFACETABLE_H 9 | #define IFACETABLE_H 10 | 11 | enum IFaceType { 12 | iface_void, 13 | iface_int, 14 | iface_length, 15 | iface_position, 16 | iface_line, 17 | iface_pointer, 18 | iface_colour, 19 | iface_colouralpha, 20 | iface_bool, 21 | iface_keymod, 22 | iface_string, 23 | iface_stringresult, 24 | iface_cells, 25 | iface_textrange, 26 | iface_findtext, 27 | iface_formatrange, 28 | iface_textrangefull, 29 | iface_findtextfull, 30 | iface_formatrangefull, 31 | }; 32 | 33 | struct IFaceConstant { 34 | const char *name; 35 | int value; 36 | }; 37 | 38 | struct IFaceFunction { 39 | const char *name; 40 | int value; 41 | IFaceType returnType; 42 | IFaceType paramType[2]; 43 | }; 44 | 45 | struct IFaceProperty { 46 | const char *name; 47 | int getter; 48 | int setter; 49 | IFaceType valueType; 50 | IFaceType paramType; 51 | 52 | IFaceFunction GetterFunction() const noexcept { 53 | IFaceFunction result = {"(property getter)", getter, valueType, {paramType, iface_void}}; 54 | return result; 55 | } 56 | 57 | IFaceFunction SetterFunction() const noexcept { 58 | IFaceFunction result = {"(property setter)", setter, iface_void, {valueType, iface_void}}; 59 | if (paramType != iface_void) { 60 | result.paramType[0] = paramType; 61 | if (valueType == iface_stringresult) 62 | result.paramType[1] = iface_string; 63 | else 64 | result.paramType[1] = valueType; 65 | } 66 | if ((paramType == iface_void) && ((valueType == iface_string) || (valueType == iface_stringresult))) { 67 | result.paramType[0] = paramType; 68 | if (valueType == iface_stringresult) 69 | result.paramType[1] = iface_string; 70 | else 71 | result.paramType[1] = valueType; 72 | } 73 | return result; 74 | } 75 | }; 76 | 77 | struct IFaceObject { 78 | const char *name; 79 | const char *prefix; 80 | IFaceType indexType; 81 | }; 82 | 83 | class IFaceTable { 84 | public: 85 | static const IFaceFunction *const functions; 86 | static const IFaceConstant *const constants; 87 | static const IFaceProperty *const properties; 88 | 89 | static const int functionCount; 90 | static const int constantCount; 91 | static const int propertyCount; 92 | 93 | static int FindConstant(const char *name) noexcept; 94 | static int FindFunction(const char *name) noexcept; 95 | static int FindFunctionByConstantName(const char *name) noexcept; 96 | static int FindProperty(const char *name) noexcept; 97 | 98 | static std::string GetConstantName(int value, const char *prefix); 99 | }; 100 | 101 | #endif 102 | -------------------------------------------------------------------------------- /src/JobQueue.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file JobQueue.h 3 | ** Define job queue 4 | **/ 5 | // SciTE & Scintilla copyright 1998-2003 by Neil Hodgson 6 | // Copyright 2007 by Neil Hodgson , from April White 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | // TODO: see http://www.codeproject.com/threads/cppsyncstm.asp 10 | 11 | #ifndef JOBQUEUE_H 12 | #define JOBQUEUE_H 13 | 14 | enum class JobSubsystem { 15 | cli = 0, gui = 1, shell = 2, extension = 3, help = 4, otherHelp = 5, grep = 6, immediate = 7 16 | }; 17 | 18 | JobSubsystem SubsystemFromChar(char c) noexcept; 19 | 20 | enum JobFlags { 21 | jobForceQueue = 1, 22 | jobHasInput = 2, 23 | jobQuiet = 4, 24 | // 8 reserved for jobVeryQuiet 25 | jobRepSelMask = 48, 26 | jobRepSelYes = 16, 27 | jobRepSelAuto = 32, 28 | jobGroupUndo = 64, 29 | jobLowPriority = 128 30 | }; 31 | 32 | struct JobMode { 33 | JobSubsystem jobType; 34 | int saveBefore; 35 | bool isFilter; 36 | int flags; 37 | std::string input; 38 | JobMode(const PropSetFile &props, int item, std::string_view fileNameExt); 39 | }; 40 | 41 | class Job { 42 | public: 43 | std::string command; 44 | FilePath directory; 45 | JobSubsystem jobType; 46 | std::string input; 47 | int flags; 48 | 49 | Job() noexcept; 50 | Job(std::string_view command_, const FilePath &directory_, JobSubsystem jobType_, std::string_view input_, int flags_); 51 | void Clear() noexcept; 52 | }; 53 | 54 | class JobQueue { 55 | std::atomic_bool cancelFlag; 56 | public: 57 | std::mutex mutex; 58 | std::atomic_bool clearBeforeExecute; 59 | std::atomic_bool isBuilding; 60 | std::atomic_bool isBuilt; 61 | std::atomic_bool executing; 62 | static constexpr size_t commandMax = 2; 63 | std::atomic_size_t commandCurrent; 64 | std::vector jobQueue; 65 | std::atomic_bool jobUsesOutputPane; 66 | std::atomic_bool timeCommands; 67 | 68 | JobQueue(); 69 | // Deleted so JobQueue objects can not be copied. 70 | JobQueue(const JobQueue &) = delete; 71 | JobQueue(JobQueue &&) = delete; 72 | JobQueue &operator=(const JobQueue &) = delete; 73 | JobQueue &operator=(JobQueue &&) = delete; 74 | ~JobQueue(); 75 | bool TimeCommands() const noexcept; 76 | bool ClearBeforeExecute() const noexcept; 77 | bool ShowOutputPane() const noexcept; 78 | bool IsExecuting() const noexcept; 79 | void SetExecuting(bool state) noexcept; 80 | bool HasCommandToRun() const noexcept; 81 | bool SetCancelFlag(bool value); 82 | bool Cancelled() noexcept; 83 | 84 | void ClearJobs() noexcept; 85 | void AddCommand(std::string_view command, const FilePath &directory, JobSubsystem jobType, std::string_view input, int flags); 86 | }; 87 | 88 | #endif 89 | -------------------------------------------------------------------------------- /src/LuaExtension.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | // LuaExtension.h - Lua scripting extension 3 | // Copyright 1998-2000 by Neil Hodgson 4 | // The License.txt file describes the conditions under which this software may be distributed. 5 | 6 | #ifndef LUAEXTENSION_H 7 | #define LUAEXTENSION_H 8 | 9 | class LuaExtension : public Extension { 10 | private: 11 | LuaExtension() noexcept; // Singleton 12 | 13 | public: 14 | static LuaExtension &Instance() noexcept; 15 | 16 | // Deleted so LuaExtension objects can not be copied. 17 | LuaExtension(const LuaExtension &) = delete; 18 | LuaExtension(LuaExtension &&) = delete; 19 | LuaExtension &operator=(const LuaExtension &) = delete; 20 | LuaExtension &operator=(LuaExtension &&) = delete; 21 | 22 | ~LuaExtension() override; 23 | 24 | bool Initialise(ExtensionAPI *host_) override; 25 | bool Finalise() noexcept override; 26 | bool Clear() override; 27 | bool Load(const char *filename) override; 28 | 29 | bool InitBuffer(int) override; 30 | bool ActivateBuffer(int) override; 31 | bool RemoveBuffer(int) override; 32 | 33 | bool OnOpen(const char *filename) override; 34 | bool OnSwitchFile(const char *filename) override; 35 | bool OnBeforeSave(const char *filename) override; 36 | bool OnSave(const char *filename) override; 37 | bool OnChar(char ch) override; 38 | bool OnExecute(const char *s) override; 39 | bool OnSavePointReached() override; 40 | bool OnSavePointLeft() override; 41 | bool OnStyle(Scintilla::Position startPos, Scintilla::Position lengthDoc, int initStyle, StyleWriter *styler) override; 42 | bool OnDoubleClick() override; 43 | bool OnUpdateUI() override; 44 | bool OnMarginClick() override; 45 | bool OnUserListSelection(int listType, const char *selection) override; 46 | bool OnKey(int keyval, int modifiers) override; 47 | bool OnDwellStart(Scintilla::Position pos, const char *word) override; 48 | bool OnClose(const char *filename) override; 49 | bool OnUserStrip(int control, int change) override; 50 | bool NeedsOnClose() override; 51 | }; 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/MatchMarker.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file MatchMarker.h 3 | ** Mark all the matches of a string. 4 | **/ 5 | // Copyright 1998-2014 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef MATCHMARKER_H 9 | #define MATCHMARKER_H 10 | 11 | struct LineRange { 12 | Scintilla::Line lineStart; 13 | Scintilla::Line lineEnd; 14 | LineRange(Scintilla::Line lineStart_, Scintilla::Line lineEnd_) noexcept : lineStart(lineStart_), lineEnd(lineEnd_) {} 15 | }; 16 | 17 | std::vector LinesBreak(Scintilla::ScintillaCall *pSci); 18 | 19 | class MatchMarker { 20 | Scintilla::ScintillaCall *pSci; 21 | std::string textMatch; 22 | int styleMatch; 23 | Scintilla::FindOption flagsMatch; 24 | int indicator; 25 | int bookMark; 26 | std::optional showContext; 27 | std::vector lineRanges; 28 | std::set matches; 29 | public: 30 | MatchMarker(); // Not noexcept as std::vector constructor throws 31 | void StartMatch(Scintilla::ScintillaCall *pSci_, 32 | const std::string &textMatch_, Scintilla::FindOption flagsMatch_, int styleMatch_, 33 | int indicator_, int bookMark_, std::optional showContext_={}); 34 | bool Complete() const noexcept; 35 | void Continue(); 36 | void Stop() noexcept; 37 | }; 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /src/PathMatch.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file PathMatch.h 3 | ** Match path patterns. 4 | **/ 5 | // Copyright 2018 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef PATHMATCH_H 9 | #define PATHMATCH_H 10 | 11 | bool PatternMatch(std::u32string_view pattern, std::u32string_view text) noexcept; 12 | bool PathMatch(std::string pattern, std::string relPath); 13 | 14 | #endif 15 | -------------------------------------------------------------------------------- /src/PropSetFile.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file PropSetFile.h 3 | ** Definition of platform independent base class of editor. 4 | **/ 5 | // Copyright 1998-2009 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef PROPSETFILE_H 9 | #define PROPSETFILE_H 10 | 11 | /** 12 | */ 13 | 14 | typedef std::map> mapss; 15 | 16 | class ImportFilter { 17 | public: 18 | std::set excludes; 19 | std::set includes; 20 | void SetFilter(const std::string &sExcludes, const std::string &sIncludes); 21 | bool IsValid(const std::string &name) const; 22 | }; 23 | 24 | class PropSetFile { 25 | bool lowerKeys; 26 | std::string_view GetWildUsingStart(const PropSetFile &psStart, std::string_view keybase, std::string_view filename) const; 27 | static bool caseSensitiveFilenames; 28 | mapss props; 29 | public: 30 | PropSetFile *superPS; 31 | explicit PropSetFile(bool lowerKeys_=false); 32 | 33 | void Set(std::string_view key, std::string_view val); 34 | void SetPath(std::string_view key, const FilePath &path); 35 | void SetLine(const char *keyVal, bool unescape); 36 | void Unset(std::string_view key); 37 | void Clear() noexcept; 38 | 39 | bool Exists(std::string_view key) const; 40 | [[nodiscard]] std::string_view Get(std::string_view key) const; 41 | std::string GetString(std::string_view key) const; 42 | std::string Evaluate(std::string_view key) const; 43 | std::string GetExpandedString(std::string_view key) const; 44 | std::string Expand(std::string_view withVars, int maxExpands=200) const; 45 | int GetInt(std::string_view key, int defaultValue=0) const; 46 | intptr_t GetInteger(std::string_view key, intptr_t defaultValue=0) const; 47 | long long GetLongLong(std::string_view key, long long defaultValue=0) const; 48 | 49 | enum class ReadLineState { active, excludedModule, conditionFalse }; 50 | ReadLineState ReadLine(const std::string &lineBuffer, ReadLineState rls, const FilePath &directoryForImports, const ImportFilter &filter, 51 | FilePathSet *imports, size_t depth); 52 | void ReadFromMemory(std::string_view data, const FilePath &directoryForImports, const ImportFilter &filter, 53 | FilePathSet *imports, size_t depth); 54 | void Import(const FilePath &filename, const FilePath &directoryForImports, const ImportFilter &filter, 55 | FilePathSet *imports, size_t depth); 56 | bool Read(const FilePath &filename, const FilePath &directoryForImports, const ImportFilter &filter, 57 | FilePathSet *imports, size_t depth); 58 | std::string_view GetWild(std::string_view keybase, std::string_view filename) const; 59 | std::string GetNewExpandString(std::string_view keybase, std::string_view filename = "") const; 60 | bool GetFirst(const char *&key, const char *&val) const; 61 | bool GetNext(const char *&key, const char *&val) const; 62 | static void SetCaseSensitiveFilenames(bool caseSensitiveFilenames_) noexcept { 63 | caseSensitiveFilenames = caseSensitiveFilenames_; 64 | } 65 | }; 66 | 67 | constexpr const char *extensionProperties = ".properties"; 68 | bool IsPropertiesFile(const FilePath &filename); 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /src/SciTE.properties: -------------------------------------------------------------------------------- 1 | # SciTE.properties is the per directory local options file and can be used to 2 | # override settings made in SciTEGlobal.properties, SciTEUser.properties and 3 | # SciTEDirectory.properties. 4 | command.build.directory.*.cxx=..\win32 5 | command.build.directory.*.h=..\win32 6 | command.build.*.cxx=nmake -f scite.mak DEBUG=1 QUIET=1 7 | command.build.*.h=nmake -f scite.mak DEBUG=1 QUIET=1 8 | command.go.*.cxx=..\bin\SciTE 9 | command.go.*.h=..\bin\SciTE 10 | command.go.needs.*.cxx=cmd /c cd ..\win32 && nmake -f scite.mak DEBUG=1 QUIET=1 11 | -------------------------------------------------------------------------------- /src/SciTEGlobal.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/src/SciTEGlobal.properties -------------------------------------------------------------------------------- /src/SciTEKeys.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file SciTEKeys.h 3 | ** SciTE keyboard shortcut facilities. 4 | **/ 5 | // Copyright 1998-2004 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef SCITEKEYS_H 9 | #define SCITEKEYS_H 10 | 11 | class SciTEKeys { 12 | public: 13 | static long ParseKeyCode(std::string_view mnemonic); 14 | static bool MatchKeyCode(long parsedKeyCode, int keyval, int modifiers) noexcept; 15 | }; 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/ScintillaWindow.cxx: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file ScintillaWindow.cxx 3 | ** Interface to a Scintilla instance. 4 | **/ 5 | // Copyright 1998-2018 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #include "ScintillaTypes.h" 13 | #include "ScintillaMessages.h" 14 | #include "ScintillaCall.h" 15 | 16 | #include "Scintilla.h" 17 | 18 | #include "GUI.h" 19 | #include "ScintillaWindow.h" 20 | 21 | namespace GUI { 22 | 23 | ScintillaWindow::ScintillaWindow() noexcept = default; 24 | 25 | ScintillaWindow::~ScintillaWindow() = default; 26 | 27 | void ScintillaWindow::SetScintilla(GUI::WindowID wid_) { 28 | SetID(wid_); 29 | if (wid) { 30 | SciFnDirectStatus fn_ = reinterpret_cast( 31 | Send(static_cast(Scintilla::Message::GetDirectStatusFunction))); 32 | const sptr_t ptr_ = Send(static_cast(Scintilla::Message::GetDirectPointer)); 33 | SetFnPtr(fn_, ptr_); 34 | } 35 | } 36 | 37 | bool ScintillaWindow::CanCall() const noexcept { 38 | return wid && IsValid(); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /src/ScintillaWindow.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file ScintillaWindow.h 3 | ** Interface to a Scintilla instance. 4 | **/ 5 | // Copyright 1998-2018 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef SCINTILLAWINDOW_H 9 | #define SCINTILLAWINDOW_H 10 | 11 | namespace GUI { 12 | 13 | class ScintillaWindow : public GUI::ScintillaPrimitive, public Scintilla::ScintillaCall { 14 | public: 15 | ScintillaWindow() noexcept; 16 | ~ScintillaWindow() override; 17 | // Deleted so ScintillaWindow objects can not be copied. 18 | ScintillaWindow(const ScintillaWindow &source) = delete; 19 | ScintillaWindow(ScintillaWindow &&) = delete; 20 | ScintillaWindow &operator=(const ScintillaWindow &) = delete; 21 | ScintillaWindow &operator=(ScintillaWindow &&) = delete; 22 | 23 | void SetScintilla(GUI::WindowID wid_); 24 | bool CanCall() const noexcept; 25 | }; 26 | 27 | } 28 | 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/Searcher.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file Searcher.h 3 | ** Definitions of search functionality. 4 | **/ 5 | // Copyright 1998-2011 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef SEARCHER_H 9 | #define SEARCHER_H 10 | 11 | // Interface between SciTE and dialogs and strips for find and replace 12 | class Searcher { 13 | public: 14 | std::string findWhat; 15 | std::string replaceWhat; 16 | 17 | bool wholeWord; 18 | bool matchCase; 19 | bool regExp; 20 | bool unSlash; 21 | bool wrapFind; 22 | bool reverseFind; 23 | bool filterState; 24 | bool contextVisible; 25 | 26 | Scintilla::Position searchStartPosition; 27 | bool replacing; 28 | bool havefound; 29 | bool failedfind; 30 | bool findInStyle; 31 | int findStyle; 32 | enum class CloseFind { closePrevent, closeAlways, closeOnMatch } closeFind; 33 | ComboMemory memFinds; 34 | ComboMemory memReplaces; 35 | 36 | bool focusOnReplace; 37 | 38 | Searcher(); 39 | 40 | virtual void SetFindText(std::string_view sFind) = 0; 41 | virtual void SetFind(std::string_view sFind) = 0; 42 | virtual bool FindHasText() const noexcept = 0; 43 | void InsertFindInMemory(); 44 | virtual void SetReplace(std::string_view sReplace) = 0; 45 | virtual void SetCaretAsStart() = 0; 46 | virtual void MoveBack() = 0; 47 | virtual void ScrollEditorIfNeeded() = 0; 48 | 49 | virtual Scintilla::Position FindNext(bool reverseDirection, bool showWarnings=true, bool allowRegExp=true) = 0; 50 | virtual void HideMatch() = 0; 51 | enum class MarkPurpose { withBookMarks, incremental, filter }; 52 | virtual void MarkAll(MarkPurpose purpose) = 0; 53 | virtual void FilterAll(bool showMatches) = 0; 54 | virtual intptr_t ReplaceAll(bool inSelection) = 0; 55 | virtual void ReplaceOnce(bool showWarnings=true) = 0; 56 | virtual void UIClosed() = 0; 57 | virtual void UIHasFocus() = 0; 58 | bool &FlagFromCmd(int cmd) noexcept; 59 | bool ShouldClose(bool found) const noexcept { 60 | return (closeFind == CloseFind::closeAlways) || (found && (closeFind == CloseFind::closeOnMatch)); 61 | } 62 | }; 63 | 64 | // User interface for search options implemented as both buttons and popup menu items 65 | struct SearchOption { 66 | enum { tWord, tCase, tRegExp, tBackslash, tWrap, tUp, tFilter, tContext }; 67 | const char *label; 68 | int cmd; // Menu item 69 | int id; // Control in dialog 70 | }; 71 | 72 | class SearchUI { 73 | protected: 74 | Searcher *pSearcher; 75 | public: 76 | SearchUI() noexcept : pSearcher(nullptr) { 77 | } 78 | void SetSearcher(Searcher *pSearcher_) noexcept { 79 | pSearcher = pSearcher_; 80 | } 81 | }; 82 | 83 | #endif 84 | -------------------------------------------------------------------------------- /src/StringList.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file StringList.h 3 | ** Definition of class holding a list of strings. 4 | **/ 5 | // Copyright 1998-2005 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef STRINGLIST_H 9 | #define STRINGLIST_H 10 | 11 | class StringList { 12 | // Text pointed into by words and wordsNoCase 13 | std::string listText; 14 | // Each word contains at least one character. 15 | std::vector words; 16 | std::vector wordsNoCase; 17 | bool onlyLineEnds; ///< Delimited by any white space or only line ends 18 | bool sorted; 19 | bool sortedNoCase; 20 | void SetFromListText(); 21 | void SortIfNeeded(bool ignoreCase); 22 | public: 23 | explicit StringList(bool onlyLineEnds_ = false) : 24 | words(0), wordsNoCase(0), onlyLineEnds(onlyLineEnds_), 25 | sorted(false), sortedNoCase(false) {} 26 | size_t Length() const noexcept { return words.size(); } 27 | operator bool() const noexcept { return !words.empty(); } 28 | char *operator[](size_t ind) noexcept { return words[ind]; } 29 | void Clear() noexcept; 30 | void Set(const char *s); 31 | void Set(const std::vector &data); 32 | std::string GetNearestWord(const char *wordStart, size_t searchLen, 33 | bool ignoreCase, const std::string &wordCharacters, ptrdiff_t wordIndex); 34 | std::string GetNearestWords(const char *wordStart, size_t searchLen, 35 | bool ignoreCase, char otherSeparator='\0', bool exactLen=false); 36 | }; 37 | 38 | class AutoCompleteWordList { 39 | std::set words; 40 | size_t totalLength = 0; 41 | size_t minWordLength = SIZE_MAX; 42 | public: 43 | size_t Count() const noexcept { 44 | return words.size(); 45 | } 46 | size_t MinWordLength() const noexcept { 47 | return minWordLength; 48 | } 49 | bool Add(const std::string& word); 50 | std::string Get() const; 51 | }; 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/StyleDefinition.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file StyleDefinition.h 3 | ** Definition of style aggregate and helper functions. 4 | **/ 5 | // Copyright 2013 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef STYLEDEFINITION_H 9 | #define STYLEDEFINITION_H 10 | 11 | class StyleDefinition { 12 | public: 13 | std::string font; 14 | float sizeFractional; 15 | int size; 16 | std::string fore; 17 | std::string back; 18 | Scintilla::FontWeight weight; 19 | Scintilla::FontStretch stretch; 20 | bool italics; 21 | bool eolfilled; 22 | bool underlined; 23 | Scintilla::CaseVisible caseForce; 24 | bool visible; 25 | bool changeable; 26 | std::string invisibleRep; 27 | enum flags { sdNone = 0, sdFont = 0x1, sdSize = 0x2, sdFore = 0x4, sdBack = 0x8, 28 | sdWeight = 0x10, sdItalics = 0x20, sdEOLFilled = 0x40, sdUnderlined = 0x80, 29 | sdCaseForce = 0x100, sdVisible = 0x200, sdChangeable = 0x400, sdInvisibleRep=0x800, 30 | sdStretch = 0x10000, 31 | } specified; 32 | explicit StyleDefinition(std::string_view definition); 33 | bool ParseStyleDefinition(std::string_view definition); 34 | Scintilla::Colour Fore() const; 35 | Scintilla::Colour Back() const; 36 | int FractionalSize() const noexcept; 37 | bool IsBold() const noexcept; 38 | }; 39 | 40 | constexpr Scintilla::Colour ColourRGB(unsigned int red, unsigned int green, unsigned int blue) noexcept { 41 | return red | (green << 8) | (blue << 16); 42 | } 43 | 44 | constexpr Scintilla::ColourAlpha ColourRGBA(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha=0xff) noexcept { 45 | return red | (green << 8) | (blue << 16) | (alpha << 24); 46 | } 47 | 48 | int IntFromHexByte(std::string_view hexByte) noexcept; 49 | 50 | Scintilla::Colour ColourFromString(std::string_view s); 51 | Scintilla::ColourAlpha ColourAlphaFromString(std::string_view s); 52 | 53 | struct IndicatorDefinition { 54 | Scintilla::IndicatorStyle style; 55 | Scintilla::Colour colour; 56 | Scintilla::Alpha fillAlpha; 57 | Scintilla::Alpha outlineAlpha; 58 | bool under; 59 | explicit IndicatorDefinition(std::string_view definition); 60 | bool ParseIndicatorDefinition(std::string_view definition); 61 | }; 62 | 63 | struct MarkerDefinition { 64 | Scintilla::MarkerSymbol style; 65 | Scintilla::Colour colour; 66 | Scintilla::Colour back = ColourRGB(0xFF,0xFF,0xFF); 67 | explicit MarkerDefinition(std::string_view definition); 68 | bool ParseMarkerDefinition(std::string_view definition); 69 | }; 70 | 71 | #endif 72 | -------------------------------------------------------------------------------- /src/StyleWriter.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file StyleWriter.h 3 | ** Simple buffered interface to the text and styles of a document held by Scintilla. 4 | **/ 5 | // Copyright 1998-2010 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef STYLEWRITER_H 9 | #define STYLEWRITER_H 10 | 11 | // Read only access to a document, its styles and other data 12 | class TextReader { 13 | protected: 14 | static constexpr Scintilla::Position extremePosition = INTPTR_MAX; 15 | /** @a bufferSize is a trade off between time taken to copy the characters 16 | * and retrieval overhead. 17 | * @a slopSize positions the buffer before the desired position 18 | * in case there is some backtracking. */ 19 | static constexpr Scintilla::Position bufferSize = 4000; 20 | static constexpr Scintilla::Position slopSize = bufferSize / 8; 21 | char buf[bufferSize+1]; 22 | Scintilla::Position startPos; 23 | Scintilla::Position endPos; 24 | int codePage; 25 | 26 | Scintilla::ScintillaCall ≻ 27 | Scintilla::Position lenDoc; 28 | 29 | bool InternalIsLeadByte(char ch) const; 30 | void Fill(Scintilla::Position position); 31 | public: 32 | explicit TextReader(Scintilla::ScintillaCall &sc_) noexcept; 33 | // Deleted so TextReader objects can not be copied. 34 | TextReader(const TextReader &source) = delete; 35 | TextReader &operator=(const TextReader &) = delete; 36 | char operator[](Scintilla::Position position) { 37 | if (position < startPos || position >= endPos) { 38 | Fill(position); 39 | } 40 | return buf[position - startPos]; 41 | } 42 | /** Safe version of operator[], returning a defined value for invalid position. */ 43 | char SafeGetCharAt(Scintilla::Position position, char chDefault=' ') { 44 | if (position < startPos || position >= endPos) { 45 | Fill(position); 46 | if (position < startPos || position >= endPos) { 47 | // Position is outside range of document 48 | return chDefault; 49 | } 50 | } 51 | return buf[position - startPos]; 52 | } 53 | bool IsLeadByte(char ch) const { 54 | return codePage && InternalIsLeadByte(ch); 55 | } 56 | void SetCodePage(int codePage_) noexcept { 57 | codePage = codePage_; 58 | } 59 | bool Match(Scintilla::Position pos, const char *s); 60 | int StyleAt(Scintilla::Position position); 61 | Scintilla::Line GetLine(Scintilla::Position position); 62 | Scintilla::Position LineStart(Scintilla::Line line); 63 | Scintilla::FoldLevel LevelAt(Scintilla::Line line); 64 | Scintilla::Position Length(); 65 | int GetLineState(Scintilla::Line line); 66 | }; 67 | 68 | // Adds methods needed to write styles and folding 69 | class StyleWriter : public TextReader { 70 | protected: 71 | char styleBuf[bufferSize]; 72 | Scintilla::Position validLen; 73 | Scintilla::Position startSeg; 74 | public: 75 | explicit StyleWriter(Scintilla::ScintillaCall &sc_) noexcept; 76 | // Deleted so StyleWriter objects can not be copied. 77 | StyleWriter(const StyleWriter &source) = delete; 78 | StyleWriter &operator=(const StyleWriter &) = delete; 79 | void Flush(); 80 | void SetLineState(Scintilla::Line line, int state); 81 | 82 | void StartAt(Scintilla::Position start); 83 | Scintilla::Position GetStartSegment() const noexcept { return startSeg; } 84 | void StartSegment(Scintilla::Position pos) noexcept; 85 | void ColourTo(Scintilla::Position pos, int chAttr); 86 | void SetLevel(Scintilla::Line line, Scintilla::FoldLevel level); 87 | }; 88 | 89 | void CopyText(Scintilla::ScintillaCall &sc_, char *buffer, Scintilla::Span range); 90 | 91 | #endif 92 | -------------------------------------------------------------------------------- /src/Utf8_16.h: -------------------------------------------------------------------------------- 1 | // @file Utf8_16.h 2 | // Copyright (C) 2002 Scott Kirkwood 3 | // 4 | // Permission to use, copy, modify, distribute and sell this code 5 | // and its documentation for any purpose is hereby granted without fee, 6 | // provided that the above copyright notice appear in all copies or 7 | // any derived copies. Scott Kirkwood makes no representations 8 | // about the suitability of this software for any purpose. 9 | // It is provided "as is" without express or implied warranty. 10 | // 11 | // Notes: Used the UTF information I found at: 12 | // http://www.cl.cam.ac.uk/~mgk25/unicode.html 13 | //////////////////////////////////////////////////////////////////////////////// 14 | 15 | #ifndef UTF8_16_H 16 | #define UTF8_16_H 17 | 18 | namespace Utf8_16 { 19 | 20 | class Reader { 21 | public: 22 | Reader() noexcept = default; 23 | 24 | // Deleted so Reader objects can not be copied. 25 | Reader(const Reader &) = delete; 26 | Reader(Reader &&) = delete; 27 | Reader &operator=(const Reader &) = delete; 28 | Reader &operator=(Reader &&) = delete; 29 | 30 | virtual ~Reader() noexcept {}; 31 | 32 | virtual std::string_view convert(std::string_view buf) = 0; 33 | virtual UniMode getEncoding() const noexcept = 0; 34 | 35 | static std::unique_ptr Allocate(); 36 | }; 37 | 38 | class Writer { 39 | public: 40 | Writer() noexcept = default; 41 | 42 | // Deleted so Writer objects can not be copied. 43 | Writer(const Writer &) = delete; 44 | Writer(Writer &&) = delete; 45 | Writer &operator=(const Writer &) = delete; 46 | Writer &operator=(Writer &&) = delete; 47 | 48 | virtual ~Writer() noexcept {}; 49 | 50 | virtual size_t fwrite(std::string_view buf, FILE *pFile) = 0; 51 | 52 | static std::unique_ptr Allocate(UniMode unicodeMode, size_t bufferSize); 53 | }; 54 | 55 | } 56 | 57 | #endif 58 | -------------------------------------------------------------------------------- /src/Worker.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file Worker.h 3 | ** Definition of classes to perform background tasks as threads. 4 | **/ 5 | // Copyright 2011 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef WORKER_H 9 | #define WORKER_H 10 | 11 | struct Worker { 12 | private: 13 | std::atomic_bool completed; 14 | std::atomic_bool cancelling; 15 | std::atomic_size_t jobSize; 16 | std::atomic_size_t jobProgress; 17 | public: 18 | Worker() noexcept : completed(false), cancelling(false), jobSize(1), jobProgress(0) { 19 | } 20 | // Deleted so Worker objects can not be copied. 21 | Worker(const Worker &) = delete; 22 | Worker(Worker &&) = delete; 23 | void operator=(const Worker &) = delete; 24 | void operator=(Worker &&) = delete; 25 | virtual ~Worker() noexcept { 26 | } 27 | virtual void Execute() noexcept {} 28 | bool FinishedJob() const noexcept { 29 | return completed; 30 | } 31 | void SetCompleted() noexcept { 32 | completed = true; 33 | } 34 | bool Cancelling() const noexcept { 35 | return cancelling; 36 | } 37 | size_t SizeJob() const noexcept { 38 | return jobSize; 39 | } 40 | void SetSizeJob(size_t size) noexcept { 41 | jobSize = size; 42 | } 43 | size_t ProgressMade() const noexcept { 44 | return jobProgress; 45 | } 46 | void IncrementProgress(size_t increment) noexcept { 47 | jobProgress += increment; 48 | } 49 | virtual void Cancel() noexcept { 50 | cancelling = true; 51 | // Wait for writing thread to finish 52 | for (;;) { 53 | if (completed) 54 | return; 55 | } 56 | } 57 | }; 58 | 59 | struct WorkerListener { 60 | virtual void PostOnMainThread(int cmd, Worker *pWorker) = 0; 61 | }; 62 | 63 | #endif 64 | -------------------------------------------------------------------------------- /src/abaqus.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for ABAQUS files. 2 | 3 | file.patterns.abaqus=*.inp;*.dat;*.msg 4 | filter.abaqus=ABAQUS input (inp)|$(file.patterns.abaqus)| 5 | 6 | *filter.abaqus=$(filter.abaqus) 7 | 8 | #lexer.$(file.patterns.abaqus)=abaqus 9 | lexer.$(file.patterns.abaqus)=abaqus 10 | 11 | # keywords and input/output specifiers 12 | keywords=*amplitude *assembly \ 13 | *beam *boundary *buckle *bulk \ 14 | *cload *conditions *conductivity *contact \ 15 | *damping *density *dload *dsflux *dsload *dynamic \ 16 | *el *elastic *element *element output *elgen *elset *encastre *end step \ 17 | *expansion *explicit *equation *embedded element \ 18 | *field *freq *frequency *friction \ 19 | *generate \ 20 | *heading *heat transfer *history \ 21 | *imperfectio *import *include *initial *initial conditions *instance *interactio \ 22 | *internal *interval \ 23 | *marks *material *monitor *mpc \ 24 | *ncopy *nfill *ngen *nlgeom *node *node output *node print *nset *number \ 25 | *output \ 26 | *pair *parameter *part *physical constants *plastic *print *preprint \ 27 | *radiate *restart \ 28 | *shell *shell section *solid section *specific heat *sradiate *static *step \ 29 | *surface \ 30 | *temperature *time *type \ 31 | *variable *viscosity 32 | 33 | arguments=elset engineering inc input line material name nset pin tie type write generate field variable history \ 34 | stefan boltzmann absolute zero zero frequency steady state new old set change number shift \ 35 | model position newset oldset host 36 | 37 | keywords.$(file.patterns.abaqus)= 38 | keywords2.$(file.patterns.abaqus)=$(keywords) 39 | keywords3.$(file.patterns.abaqus)= 40 | keywords4.$(file.patterns.abaqus)= 41 | keywords5.$(file.patterns.abaqus)=$(arguments) 42 | keywords6.$(file.patterns.abaqus)= 43 | 44 | comment.block.abaqus=** 45 | 46 | # ABAQUS styles 47 | # Default 48 | style.abaqus.0=fore:#000000 49 | # Comment 50 | style.abaqus.1=fore:#999999,$(font.comment),italics 51 | # Comment-blocks 52 | style.abaqus.2=fore:#999999,$(font.comment),italics 53 | # Number 54 | style.abaqus.3=$(colour.number) 55 | # Quoted string 56 | style.abaqus.4=$(colour.string) 57 | # Ansys operator 58 | style.abaqus.5=fore:#990000 59 | # Ansys word 60 | style.abaqus.6=fore:#000000 61 | # Ansys processor 62 | style.abaqus.7=fore:#008888,bold 63 | # Ansys command 64 | style.abaqus.8=fore:#0000CC 65 | # Ansys slashcommand 66 | style.abaqus.9=fore:#0000CC,bold 67 | # Ansys starcommand 68 | style.abaqus.10=fore:#6600DD,bold 69 | # Ansys argument 70 | style.abaqus.11=fore:#0077FF 71 | # Ansys function 72 | style.abaqus.12=fore:#0077DD 73 | 74 | command.compile.*.inp= 75 | command.build.*.inp=abaqus job=$(FileName) cpus=4 76 | command.go.*.inp= 77 | 78 | autocomplete.abaqus.ignorecase=1 79 | calltip.abaqus.ignorecase=1 80 | -------------------------------------------------------------------------------- /src/abbrev.properties: -------------------------------------------------------------------------------- 1 | # Global abbreviations file for SciTE 2 | # Place this file in your home directory, that is, the same directory 3 | # as the user options file. 4 | # Contains a list of entries of the form abbreviation=expansion 5 | # Type the abbreviation and press Ctrl+B to insert the expansion 6 | # The '|' marks the position the caret will be after expansion. 7 | 8 | #main=int main(int argc, char *argv[]) {\n|\n} 9 | #i=if (|) {\n\n} 10 | -------------------------------------------------------------------------------- /src/ada.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Ada files. 2 | 3 | filter.ada=Ada (ads adb)|*.ads;*.adb| 4 | 5 | *filter.ada=$(filter.ada) 6 | 7 | file.patterns.ada=*.ads;*.adb 8 | 9 | *source.patterns.ada=$(file.patterns.ada); 10 | 11 | lexer.$(file.patterns.ada)=ada 12 | 13 | *language.ada=Ada|ads|| 14 | 15 | #indent.size.$(file.patterns.ada)=3 16 | #use.tabs.$(file.patterns.ada)=0 17 | 18 | # Keyword except of operator keywords 19 | keywordclass.ada.main=abort abstract accept access aliased all array at begin body \ 20 | case constant declare delay delta digits do else elsif end entry exception exit for \ 21 | function generic goto if in is limited loop new null of others out package pragma \ 22 | private procedure protected raise range record renames requeue return reverse \ 23 | select separate subtype tagged task terminate then type until use when while with 24 | # Keywords for operators 25 | keywordclass.ada.operators=abs and mod not or rem xor 26 | 27 | keywordclass.ada=$(keywordclass.ada.main) $(keywordclass.ada.operators) 28 | 29 | keywords.$(file.patterns.ada)=$(keywordclass.ada) 30 | 31 | # Ada styles 32 | # Default 33 | style.ada.0=fore:#808080 34 | # Keyword 35 | style.ada.1=$(colour.keyword),bold 36 | # Identifiers 37 | style.ada.2= 38 | # Number 39 | style.ada.3=$(colour.number) 40 | # Operators (delimiters) 41 | style.ada.4=$(colour.operator),bold 42 | # Character 43 | style.ada.5=$(colour.char) 44 | # End of line where character is not closed 45 | style.ada.6=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 46 | # String 47 | style.ada.7=$(colour.string) 48 | # End of line where string is not closed 49 | style.ada.8=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 50 | # Label 51 | style.ada.9=fore:#7F0000 52 | # Comment 53 | style.ada.10=$(colour.code.comment.line),$(font.code.comment.line) 54 | # Illegal token 55 | style.ada.11=fore:#FF0000 56 | 57 | # Comments 58 | comment.block.ada=--~ 59 | 60 | braces.ada.style=4 61 | 62 | statement.indent.$(file.patterns.ada)=1 begin declare else elsif exception for if is loop while 63 | statement.lookback.$(file.patterns.ada)=20 64 | block.start.$(file.patterns.ada)=10 then is 65 | block.end.$(file.patterns.ada)=10 end 66 | 67 | calltip.ada.word.characters=._$(chars.alpha) 68 | 69 | adagcc=gcc -c $(FileNameExt) 70 | 71 | command.compile.*.ads=$(adagcc) 72 | command.build.*.ads=gnatmake 73 | command.go.*.ads=$(FileName) 74 | 75 | command.compile.*.adb=$(adagcc) 76 | command.build.*.adb=gnatmake 77 | command.go.*.adb=$(FileName) 78 | -------------------------------------------------------------------------------- /src/asciidoc.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Asciidoc files. 2 | 3 | file.patterns.asciidoc=*.adoc;*.asciidoc 4 | 5 | filter.asciidoc=Asciidoc (adoc asciidoc)|$(file.patterns.asciidoc)| 6 | *filter.asciidoc=$(filter.asciidoc) 7 | 8 | lexer.$(file.patterns.asciidoc)=asciidoc 9 | 10 | *language.asciidoc=Asciidoc|asciidoc|| 11 | 12 | # SCE_ASCIIDOC_DEFAULT: Regular text 13 | style.asciidoc.0= 14 | 15 | # SCE_ASCIIDOC_STRONG1: "*" - Strong emphasis (bold) 16 | style.asciidoc.1=fore:#224466,bold 17 | # SCE_ASCIIDOC_STRONG2: "**" - Strong emphasis (bold) 18 | style.asciidoc.2=fore:#224466,bold 19 | 20 | # SCE_ASCIIDOC_EM1: '_' - Emphasis (italic) 21 | style.asciidoc.3=fore:#663300,italics 22 | # SCE_ASCIIDOC_EM2: '__' - Emphasis (italic) 23 | style.asciidoc.4=fore:#663300,italics 24 | 25 | # SCE_ASCIIDOC_HEADER1: "# " - Level-one header 26 | style.asciidoc.5=fore:#5183C4,bold,$(font.monospace) 27 | # SCE_ASCIIDOC_HEADER2: "## " - Level-two header 28 | style.asciidoc.6=fore:#5183C4,bold,$(font.monospace) 29 | # SCE_ASCIIDOC_HEADER3: "### " - Level-three header 30 | style.asciidoc.7=fore:#5183C4,bold,$(font.monospace) 31 | # SCE_ASCIIDOC_HEADER4: "#### " - Level-four header 32 | style.asciidoc.8=fore:#5183C4,bold,$(font.monospace) 33 | # SCE_ASCIIDOC_HEADER5: "##### " - Level-five header 34 | style.asciidoc.9=fore:#5183C4,bold,$(font.monospace) 35 | # SCE_ASCIIDOC_HEADER6: "###### " - Level-six header 36 | style.asciidoc.10=fore:#5183C4,bold,$(font.monospace) 37 | 38 | # SCE_ASCIIDOC_ULIST_ITEM: "* " - Unordered list item 39 | style.asciidoc.11=fore:#555555 40 | # SCE_ASCIIDOC_OLIST_ITEM: ". " - Ordered list item 41 | style.asciidoc.12=fore:#555555 42 | 43 | # SCE_ASCIIDOC_BLOCKQUOTE: "> " - Block quote 44 | style.asciidoc.13=italics 45 | 46 | # SCE_ASCIIDOC_LINK: "[]" - Link or image 47 | style.asciidoc.14=fore:#0000AA 48 | 49 | # SCE_ASCIIDOC_CODEBK: "====" - Code block 50 | style.asciidoc.15= 51 | 52 | # SCE_ASCIIDOC_PASSBK: "++++" - Passthrough block 53 | style.asciidoc.16= 54 | 55 | # SCE_ASCIIDOC_COMMENT: "//" - Comment 56 | style.asciidoc.17=fore:#3F703F 57 | 58 | # SCE_ASCIIDOC_COMMENTBK: "////" - Comment block 59 | style.asciidoc.18=fore:#3F703F 60 | 61 | # SCE_ASCIIDOC_LITERAL: "+" - Literal 62 | style.asciidoc.19= 63 | 64 | # SCE_ASCIIDOC_LITERALBK: "...." - Literal block 65 | style.asciidoc.20= 66 | 67 | # SCE_ASCIIDOC_ATTRIB: ":" - Attribute 68 | style.asciidoc.21= 69 | 70 | # SCE_ASCIIDOC_ATTRIBVAL: ": " - Attribute value 71 | style.asciidoc.22=fore:#7F007F 72 | 73 | # SCE_ASCIIDOC_MACRO: "[]" - Macro 74 | style.asciidoc.23=fore:#0000AA 75 | -------------------------------------------------------------------------------- /src/asn1.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for ASN.1 MIB definition files. 2 | 3 | filter.asn1=ASN.1 (asn1)|*.mib| 4 | 5 | *filter.asn1=$(filter.asn1) 6 | 7 | file.patterns.asn1=*.mib 8 | 9 | lexer.$(file.patterns.asn1)=asn1 10 | 11 | *language.asn=ASN.1|mib|| 12 | 13 | # ASN.1 styles 14 | # Default 15 | style.asn1.0=fore:#000000 16 | # Comment 17 | style.asn1.1=fore:#007F00,$(font.comment) 18 | # Identifiers 19 | style.asn1.2=fore:#000000,bold 20 | # Double quoted string 21 | style.asn1.3=fore:#7F007F 22 | # Numeric OID definition 23 | style.asn1.4=fore:#007F7F,bold 24 | # Non OID numbers 25 | style.asn1.5=fore:#7F0000 26 | # Keywords 27 | style.asn1.6=fore:#00007F 28 | # Attributes 29 | style.asn1.7=fore:#F07800 30 | # Descriptors 31 | style.asn1.8=fore:#00007F 32 | # Types 33 | style.asn1.9=fore:#00007F 34 | # Operators 35 | style.asn1.10=fore:#222222 36 | 37 | # Keywords 38 | keywords.$(file.patterns.asn1)=\ 39 | ACCESS AGENT AUGMENTS \ 40 | BEGIN BITS \ 41 | CAPABILITIES CHOICE COMPLIANCE CONTACT CONVENTION \ 42 | DEFINITIONS DEFVAL DESCRIPTION DISPLAY \ 43 | END ENTERPRISE EXPORTS \ 44 | FALSE FROM \ 45 | GROUP GROUPS \ 46 | HINT \ 47 | IDENTITY IMPLIED IMPORTS INCLUDES INDEX INFO \ 48 | LAST \ 49 | MANDATORY MAX MIN MODULE \ 50 | NOTATION NOTIFICATION NULL \ 51 | OBJECTS OBJECT-TYPE OF ORGANIZATION \ 52 | PRODUCT \ 53 | RELEASE REFERENCE REQUIRES REVISION \ 54 | SEQUENCE SIZE STATUS SUPPORTS SYNTAX \ 55 | TEXTUAL TRAP TYPE TRAP-TYPE \ 56 | UPDATED \ 57 | VALUE VARIABLES VARIATION \ 58 | WRITE 59 | 60 | # Attributes 61 | keywords2.$(file.patterns.asn1)=\ 62 | accessible \ 63 | create current \ 64 | deprecated \ 65 | for \ 66 | mandatory \ 67 | not notify not-accessible \ 68 | obsolete only optional \ 69 | read read-only read-write \ 70 | write 71 | 72 | # Descriptors 73 | keywords3.$(file.patterns.asn1)=\ 74 | ABSENT ANY APPLICATION \ 75 | BIT BOOLEAN BY \ 76 | COMPONENT COMPONENTS \ 77 | DEFAULT DEFINED \ 78 | ENUMERATED EXPLICIT EXTERNAL \ 79 | IMPLICIT INIFINITY \ 80 | MAX MIN MINUS \ 81 | OPTIONAL \ 82 | PRESENT PRIVATE \ 83 | REAL \ 84 | SET \ 85 | TAGS TRUE 86 | 87 | # Types 88 | keywords4.$(file.patterns.asn1)=\ 89 | Counter Counter32 Counter64 \ 90 | DisplayString \ 91 | Gauge Gauge32 \ 92 | IDENTIFIER INTEGER Integer32 IpAddress \ 93 | NetworkAddress NsapAddress \ 94 | OBJECT OCTET Opaque \ 95 | PhysAddress \ 96 | STRING \ 97 | TimeTicks \ 98 | UInteger32 UNITS Unsigned32 99 | 100 | -------------------------------------------------------------------------------- /src/bullant.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Bullant files. 2 | 3 | filter.bullant=Bullant (.ant)|*.ant| 4 | 5 | *filter.bullant=$(filter.bullant) 6 | 7 | file.patterns.bullant=*.ant 8 | 9 | lexer.$(file.patterns.bullant)=bullant 10 | 11 | *language.bullant=Bullant|ant|| 12 | 13 | keywordclass.bullant=abstract all ancestor and application \ 14 | assert attributes author \ 15 | begin \ 16 | callback class concrete config constants construct continue \ 17 | depends description downcast driver \ 18 | elif else ensures error exception exposure extension \ 19 | false fatal final function \ 20 | generics glyph \ 21 | help hidden host \ 22 | immutable in inherits is \ 23 | kernel \ 24 | label leave library locals \ 25 | mutable \ 26 | none not null \ 27 | obsolete options or other \ 28 | parameters peer private public \ 29 | raise reason restricted retry return \ 30 | returns rollback route \ 31 | security self settings severity step \ 32 | task test transaction true \ 33 | unknown \ 34 | varying \ 35 | warning when \ 36 | method end if until while trap case debug for foreach lock \ 37 | boolean \ 38 | character character$ \ 39 | date date$ datetime datetime$ \ 40 | float \ 41 | hex$ \ 42 | identifier identifier$ integer interval interval$ \ 43 | money money$ \ 44 | raw raw$ \ 45 | string \ 46 | tick tick$ time time$ \ 47 | version version$ 48 | 49 | 50 | keywords.$(file.patterns.bullant)=$(keywordclass.bullant) 51 | 52 | # Bullant styles 53 | # White space 54 | style.bullant.0=fore:#000000,$(font.monospace) 55 | # Comment 56 | style.bullant.1=fore:#007F00,$(font.monospace) 57 | # Line Comment 58 | style.bullant.2=fore:#007F00,$(font.monospace) 59 | # Doc comment 60 | style.bullant.3=fore:#7F7F7F 61 | # Number 62 | style.bullant.4=fore:#007F7F 63 | 64 | 65 | # Keyword 66 | style.bullant.5=fore:#00007F,bold 67 | # Double quoted string 68 | style.bullant.6=fore:#7F007F,$(font.monospace) 69 | # Single quoted string 70 | style.bullant.7=fore:#7F007F,$(font.monospace) 71 | # Symbols 72 | style.bullant.8=fore:#007F7F 73 | # Preprocessor 74 | style.bullant.9=fore:#7F7F00 75 | 76 | # compile 77 | command.compile.*.ant= 78 | 79 | # normal execute 80 | command.go.*.ant= 81 | command.go.subsystem.*.ant= 82 | 83 | #build=compile ... 84 | command.build.*.ant= 85 | command.build.subsystem.*.ant= 86 | 87 | -------------------------------------------------------------------------------- /src/coffeescript.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for CoffeeScript files. 2 | 3 | filter.coffeescript=CoffeeScript (coffee)|*.coffee| 4 | 5 | file.patterns.coffeescript=*.coffee 6 | 7 | lexer.$(file.patterns.coffeescript)=coffeescript 8 | 9 | #fold.coffeescript.comment=1 10 | 11 | style.coffeescript.32=$(font.base) 12 | # White space 13 | style.coffeescript.0=fore:#808080 14 | # SCE_COFFEESCRIPT_COMMENT allocated but unused 15 | style.coffeescript.1=$(colour.code.comment.box),$(font.code.comment.box) 16 | # Line Comment 17 | style.coffeescript.2=$(colour.code.comment.line),$(font.code.comment.line) 18 | # SCE_COFFEESCRIPT_COMMENTDOC allocated but unused 19 | style.coffeescript.3=$(colour.code.comment.doc),$(font.code.comment.doc) 20 | # Number 21 | style.coffeescript.4=$(colour.number) 22 | # Keyword 23 | style.coffeescript.5=$(colour.keyword),bold 24 | # Double quoted string 25 | style.coffeescript.6=$(colour.string) 26 | # Single quoted string 27 | style.coffeescript.7=$(colour.char) 28 | # SCE_COFFEESCRIPT_UUID allocated but unused 29 | style.coffeescript.8=fore:#804080 30 | # SCE_COFFEESCRIPT_PREPROCESSOR allocated but unused 31 | style.coffeescript.9=$(colour.preproc) 32 | # Operators 33 | style.coffeescript.10=$(colour.operator),bold 34 | # Identifiers 35 | style.coffeescript.11= 36 | # SCE_COFFEESCRIPT_STRINGEOL allocated but unused 37 | style.coffeescript.12=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 38 | # SCE_COFFEESCRIPT_VERBATIM allocated but unused 39 | style.coffeescript.13=fore:#007F00,$(font.monospace),back:#E0FFE0,eolfilled 40 | # Regular expressions 41 | style.coffeescript.14=fore:#3F7F3F,$(font.monospace),back:#E0F0FF,eolfilled 42 | # SCE_COFFEESCRIPT_COMMENTLINEDOC allocated but unused 43 | style.coffeescript.15=$(colour.code.comment.doc),$(font.code.comment.doc) 44 | # Keywords2 45 | style.coffeescript.16=fore:#B00040 46 | # SCE_COFFEESCRIPT_COMMENTDOCKEYWORD allocated but unused 47 | style.coffeescript.17=fore:#3060A0,$(font.code.comment.doc) 48 | # SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR allocated but unused 49 | style.coffeescript.18=fore:#804020,$(font.code.comment.doc) 50 | # Global class 51 | style.coffeescript.19=fore:#DD9900 52 | # SCE_COFFEESCRIPT_STRINGRAW allocated but unused 53 | style.coffeescript.20=$(colour.string),back:#FFF3FF,eolfilled 54 | # SCE_COFFEESCRIPT_TRIPLEVERBATIM allocated but unused 55 | style.coffeescript.21=$(font.monospace),fore:#007F00,back:#E0FFE0,eolfilled 56 | # Comment block ### 57 | style.coffeescript.22=$(font.monospace),fore:#007F00,back:#E7FFD7,eolfilled 58 | # Verbose REGEX 59 | style.coffeescript.23=fore:#659900 60 | # Verbose REGEX comment 61 | style.coffeescript.24=$(colour.code.comment.doc) 62 | # Iinstance property 63 | style.coffeescript.25=fore:#C06000 64 | -------------------------------------------------------------------------------- /src/css.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/src/css.properties -------------------------------------------------------------------------------- /src/eiffel.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Eiffel files. 2 | 3 | filter.eiffel=Eiffel (e)|*.e| 4 | 5 | *filter.eiffel=$(filter.eiffel) 6 | 7 | file.patterns.eiffel=*.e 8 | 9 | *source.patterns.eiffel=$(file.patterns.eiffel); 10 | 11 | # Main Eiffel lexer dows indentation based folding 12 | lexer.$(file.patterns.eiffel)=eiffel 13 | # Alternative key word based folding has trouble with redefine and rename clauses 14 | #lexer.$(file.patterns.eiffel)=eiffelkw 15 | 16 | *language.eiffel=&Eiffel|e|| 17 | 18 | # These keywords are case insensitive although Eiffel has conventions for 19 | # keywords, predefined names and predefined classes: alias, Current, BOOLEAN 20 | # Could differentiate between these 21 | keywordclass.eiffel=\ 22 | alias all and any as bit boolean \ 23 | check class character clone create creation current \ 24 | debug deferred div do double \ 25 | else elseif end ensure equal expanded export external \ 26 | false feature forget from frozen general \ 27 | if implies indexing infix inherit inspect integer invariant is \ 28 | language like local loop mod name nochange none not \ 29 | obsolete old once or platform pointer prefix precursor \ 30 | real redefine rename require rescue result retry \ 31 | select separate string strip then true undefine unique until \ 32 | variant void when xor 33 | 34 | keywords.$(file.patterns.eiffel)=$(keywordclass.eiffel) 35 | 36 | # Eiffel styles 37 | # Default 38 | style.eiffel.0=fore:#808080 39 | style.eiffelkw.0=$(style.eiffel.0) 40 | # Line comment 41 | style.eiffel.1=$(colour.code.comment.line),$(font.code.comment.line) 42 | style.eiffelkw.1=$(style.eiffel.1) 43 | # Number 44 | style.eiffel.2=$(colour.number) 45 | style.eiffelkw.2=$(style.eiffel.2) 46 | # Keyword 47 | style.eiffel.3=$(colour.keyword),bold 48 | style.eiffelkw.3=$(style.eiffel.3) 49 | # String 50 | style.eiffel.4=$(colour.string),$(font.monospace) 51 | style.eiffelkw.4=$(style.eiffel.4) 52 | # Character 53 | style.eiffel.5=$(colour.char),$(font.monospace) 54 | style.eiffelkw.5=$(style.eiffel.5) 55 | # Operators 56 | style.eiffel.6=$(colour.operator),bold 57 | style.eiffelkw.6=$(style.eiffel.6) 58 | # Identifier 59 | style.eiffel.7= 60 | style.eiffelkw.7=$(style.eiffel.7) 61 | # End of line where string is not closed 62 | style.eiffel.8=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 63 | style.eiffelkw.8=$(style.eiffel.8) 64 | # Braces are only matched in operator style 65 | braces.eiffel.style=6 66 | braces.eiffelkw.style=$(braces.eiffel.style) 67 | 68 | statement.indent.$(file.patterns.eiffel)=3 do else elsif rescue if is loop 69 | statement.end.$(file.patterns.eiffel)=10 ; 70 | statement.lookback.$(file.patterns.eiffel)=20 71 | block.start.$(file.patterns.eiffel)=10 check debug deferred do from if inspect once 72 | block.end.$(file.patterns.eiffel)=10 end 73 | 74 | command.compile.*.e=compile $(FileName) -------------------------------------------------------------------------------- /src/gap.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for GAP files. 2 | 3 | file.patterns.gap=*.g;*.gd;*.gi 4 | 5 | # GAP files 6 | filter.gap=Gap (g gi gd)|$(file.patterns.gap)| 7 | 8 | *filter.gap=$(filter.gap) 9 | 10 | *source.patterns.gap=$(file.patterns.gap); 11 | 12 | lexer.$(file.patterns.gap)=gap 13 | 14 | *language.gap=Gap|g|| 15 | 16 | keywords.$(file.patterns.gap)=and break continue do elif else end fi for function \ 17 | if in local mod not od or quit rec repeat return then until while QUIT 18 | 19 | keywords2.$(file.patterns.gap)=false true IsBound Unbind TryNextMethod \ 20 | Info Assert SaveWorkspace fail 21 | 22 | #keywords3.$(file.patterns.gap) 23 | 24 | comment.block.gap=#~ 25 | 26 | # GAP styles 27 | # White space 28 | style.gap.0=fore:#808080 29 | # Identifiers 30 | style.gap.1= 31 | # Keywords 32 | style.gap.2=$(colour.keyword),bold 33 | # Keywords 2 34 | style.gap.3=$(colour.keyword) 35 | # Keywords 3 36 | style.gap.4=$(colour.keyword) 37 | # Keywords 4 38 | style.gap.5=$(colour.keyword) 39 | # Strings 40 | style.gap.6=$(colour.string) 41 | # Characters 42 | style.gap.7=$(colour.char) 43 | # Operators 44 | style.gap.8=$(colour.operator),bold 45 | # Comment 46 | style.gap.9=$(colour.code.comment.line) 47 | # Numbers 48 | style.gap.10=$(colour.number) 49 | # End of line where string is not closed 50 | style.gap.11=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 51 | 52 | # Braces are only matched in operator style 53 | braces.gap.style=8 54 | -------------------------------------------------------------------------------- /src/haskell.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Haskell. 2 | 3 | lexer.*.hs=haskell 4 | filter.hs=Haskell (hs)|*.hs| 5 | 6 | *filter.hs=$(filter.hs) 7 | 8 | *language.haskell=Haskell|hs|| 9 | 10 | #fold.haskell.imports=1 11 | #lexer.haskell.allow.hash=0 12 | #lexer.haskell.allow.questionmark=1 13 | #lexer.haskell.allow.quotes=0 14 | #lexer.haskell.cpp=0 15 | #lexer.haskell.import.safe=0 16 | 17 | # white space 18 | style.haskell.0=fore:#808080 19 | # identifier 20 | style.haskell.1= 21 | # keyword 22 | style.haskell.2=$(colour.keyword),bold 23 | # numbers 24 | style.haskell.3=$(colour.number) 25 | # string 26 | style.haskell.4=$(colour.string) 27 | # character 28 | style.haskell.5=$(colour.char) 29 | # class: error not implemented 30 | style.haskell.6=back:#FF0000 31 | # module 32 | style.haskell.7= 33 | # capital 34 | style.haskell.8= 35 | # data: error not implemented 36 | style.haskell.9=back:#FF0000 37 | # import: error not implemented 38 | style.haskell.10=back:#FF0000 39 | # operator 40 | style.haskell.11=$(colour.operator),bold 41 | # instance: error not implemented 42 | style.haskell.12=back:#FF0000 43 | # line comment 44 | style.haskell.13=$(colour.code.comment.line),$(font.code.comment.line) 45 | # block comment 46 | style.haskell.14=$(colour.code.comment.box),$(font.code.comment.box) 47 | # block comment 2 48 | style.haskell.15=$(colour.code.comment.box),$(font.code.comment.box) 49 | # block comment 3 50 | style.haskell.16=$(colour.code.comment.box),$(font.code.comment.box) 51 | # pragma 52 | style.haskell.17=fore:#BF6F00 53 | # preprocessor 54 | style.haskell.18=$(colour.preproc) 55 | # End of line where string is not closed 56 | style.haskell.19=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 57 | # Reserved operator 58 | style.haskell.20=back:#FF8080 59 | 60 | # Available in literatehaskell lexer: 61 | # Literate comment 62 | style.haskell.21=fore:#DD9900,$(font.code.comment.line),italics 63 | # Literate delimiter 64 | style.haskell.22=fore:#EE00AA 65 | 66 | # keywords for Haskell 98 67 | keywordclass.haskell98=case class data default deriving do else hiding if \ 68 | import in infix infixl infixr instance let module \ 69 | newtype of then type where forall foreign 70 | 71 | # keywords for FFI 72 | keywordclass.ffi=export label dynamic safe threadsafe \ 73 | unsafe stdcall ccall prim 74 | 75 | keywords.*.hs=$(keywordclass.haskell98) 76 | 77 | keywords2.*.hs=$(keywordclass.ffi) 78 | -------------------------------------------------------------------------------- /src/hex.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Motorola S-Record and Intel HEX files. 2 | 3 | file.patterns.srec=*.mot;*.srec 4 | file.patterns.ihex=*.hex 5 | file.patterns.tehex=*.tek 6 | 7 | filter.srec=S-Record (mot)|$(file.patterns.srec)| 8 | filter.ihex=Intel HEX (hex)|$(file.patterns.ihex)| 9 | filter.tehex=Tektronix extended HEX (tek)|$(file.patterns.tehex)| 10 | 11 | *filter.srec=$(filter.srec) 12 | *filter.ihex=$(filter.ihex) 13 | *filter.tehex=$(filter.tehex) 14 | 15 | lexer.$(file.patterns.srec)=srec 16 | lexer.$(file.patterns.ihex)=ihex 17 | lexer.$(file.patterns.tehex)=tehex 18 | 19 | *language.srecord=S-Record|mot|| 20 | *language.intelhex=Intel HEX|hex|| 21 | *language.tektronixhex=Tektronix extended HEX|tek|| 22 | 23 | # Default 24 | style.srec.0= 25 | # Record start 'S' 26 | style.srec.1=$(style.srec.2) 27 | # Record type 28 | style.srec.2=fore:#7F0000 29 | # Record type unknown 30 | style.srec.3=$(style.srec.2),$(style.srec.10) 31 | # Byte count field: Correct byte count 32 | style.srec.4=fore:#7F7F00 33 | # Byte count field: Wrong byte count 34 | style.srec.5=$(colour.error) 35 | # Address field: No address 36 | style.srec.6=fore:#7F00FF 37 | # Address field: Data address 38 | style.srec.7=fore:#007FFF 39 | # Address field: Record count 40 | style.srec.8=$(style.srec.6) 41 | # Address field: Start address 42 | style.srec.9=$(style.srec.7) 43 | # Address field: Type unknown (this state does not contain any characters) 44 | style.srec.10=italics 45 | # .11 N/A 46 | # Data odd 47 | style.srec.12=bold 48 | # Data even 49 | style.srec.13= 50 | # Data field: Position unknown 51 | style.srec.14=$(style.srec.10) 52 | # Data field empty (this state does not contain any characters) 53 | style.srec.15= 54 | # Checksum field: Correct checksum 55 | style.srec.16=fore:#00BF00 56 | # Checksum field: Wrong checksum 57 | style.srec.17=$(colour.error) 58 | # Garbage data after the record 59 | style.srec.18=$(style.srec.10) 60 | 61 | # Same color scheme as above, comments when differing 62 | style.ihex.0=$(style.srec.0) 63 | # Record start ':' 64 | style.ihex.1=$(style.srec.1) 65 | style.ihex.2=$(style.srec.2) 66 | style.ihex.3=$(style.srec.3) 67 | style.ihex.4=$(style.srec.4) 68 | style.ihex.5=$(style.srec.5) 69 | style.ihex.6=$(style.srec.6) 70 | style.ihex.7=$(style.srec.7) 71 | # .8 N/A 72 | # Data field: Start address 73 | style.ihex.9=$(style.srec.9) 74 | # Address field: Type unknown (4 digits as usual) 75 | style.ihex.10=$(style.srec.10) 76 | # Data field: Extended address 77 | style.ihex.11=$(style.ihex.9) 78 | style.ihex.12=$(style.srec.12) 79 | style.ihex.13=$(style.srec.13) 80 | # Data field: Type unknown 81 | style.ihex.14=$(style.srec.14) 82 | style.ihex.15=$(style.srec.15) 83 | style.ihex.16=$(style.srec.16) 84 | style.ihex.17=$(style.srec.17) 85 | style.ihex.18=$(style.srec.18) 86 | 87 | # Same color scheme as above, comments when differing 88 | style.tehex.0=$(style.srec.0) 89 | # Record start '%' 90 | style.tehex.1=$(style.srec.1) 91 | style.tehex.2=$(style.srec.2) 92 | style.tehex.3=$(style.srec.3) 93 | style.tehex.4=$(style.srec.4) 94 | style.tehex.5=$(style.srec.5) 95 | # .6 N/A 96 | style.tehex.7=$(style.srec.7) 97 | # .8 N/A 98 | style.tehex.9=$(style.srec.9) 99 | # Address field: Type unknown (9 digits as usual) 100 | style.tehex.10=$(style.srec.10) 101 | # .11 N/A 102 | style.tehex.12=$(style.srec.12) 103 | style.tehex.13=$(style.srec.13) 104 | # .14 N/A 105 | # .15 N/A 106 | style.tehex.16=$(style.srec.16) 107 | style.tehex.17=$(style.srec.17) 108 | style.tehex.18=$(style.srec.18) 109 | -------------------------------------------------------------------------------- /src/json.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for JSON files. 2 | 3 | file.patterns.json=*.json;*.eslintrc;*.jshintrc;*.jsonld;*.ipynb;*.babelrc;*.prettierrc;*.stylelintrc;*.jsonc;*.jscop 4 | *source.patterns.json=$(file.patterns.json); 5 | 6 | filter.json=JSON (json eshintrc jshintrc)|$(file.patterns.json)| 7 | *filter.json=$(filter.json) 8 | 9 | lexer.$(file.patterns.json)=json 10 | 11 | *language.json=JSON|json|| 12 | 13 | lexer.json.allow.comments=1 14 | lexer.json.escape.sequence=1 15 | 16 | # JSON keywords 17 | keywords.$(file.patterns.json)=false true null 18 | 19 | # JSON-LD keywords 20 | keywords2.$(file.patterns.json)=@id @context @type @value @language @container \ 21 | @list @set @reverse @index @base @vocab @graph 22 | 23 | # Default 24 | style.json.0=fore:FFFFFF 25 | # Number 26 | style.json.1=fore:#007F7F 27 | # String 28 | style.json.2=fore:#7F0000 29 | # Unclosed string 30 | style.json.3=fore:#FFFFFF,back:#FF0000,eolfilled 31 | # Property name 32 | style.json.4=fore:#880AE8 33 | # Escape sequence 34 | style.json.5=fore:#0B982E 35 | # Line comment 36 | style.json.6=fore:#05BBAE,italics 37 | # Block comment 38 | style.json.7=$(style.json.6) 39 | # Operator 40 | style.json.8=fore:#18644A 41 | # URL/IRI 42 | style.json.9=fore:#0000FF 43 | # JSON-LD compact IRI 44 | style.json.10=fore:#D137C1 45 | # JSON keyword 46 | style.json.11=fore:#0BCEA7,bold 47 | # JSON-LD keyword 48 | style.json.12=fore:#EC2806 49 | # Parsing error 50 | style.json.13=fore:#FFFFFF,back:#FF0000 51 | -------------------------------------------------------------------------------- /src/kix.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Assembler files 2 | # Black Horus blackhorus@gmx.net 3 | 4 | # Masm files 5 | file.patterns.kix=*.kix 6 | filter.kix=Kix-Script (kix)|$(file.patterns.kix)| 7 | 8 | *filter.kix=$(filter.kix) 9 | 10 | #lexer.$(file.patterns.kix)=asm 11 | lexer.$(file.patterns.kix)=kix 12 | 13 | *language.kix=&Kix|kix|| 14 | 15 | # These keywords are commands 16 | keywords.$(file.patterns.kix)=? and beep big break call cd cls color cookie1 copy \ 17 | debug del dim display do until exit flushkb for each next function endfunction \ 18 | get gets global go gosub goto if else endif md or password play quit \ 19 | rd redim return run select case endselect set setl setm settime \ 20 | shell sleep small use while loop 21 | 22 | # This keywords are functions 23 | keywords2.$(file.patterns.kix)=abs addkey addprinterconnection addprogramgroup \ 24 | addprogramitem asc ascan at backupeventlog box cdbl chr cint cleareventlog \ 25 | close comparefiletimes createobject cstr dectohex delkey delprinterconnection \ 26 | delprogramgroup delprogramitem deltree delvalue dir enumgroup enumipinfo enumkey \ 27 | enumlocalgroup enumvalue execute exist existkey expandenvironmentvars fix \ 28 | formatnumber freefilehandle getdiskspace getfileattr getfilesize getfiletime \ 29 | getfileversion getobject iif ingroup instr instrrev int isdeclared join \ 30 | kbhit keyexist lcase left len loadhive loadkey logevent logoff ltrim \ 31 | memorysize messagebox open readline readprofilestring readtype readvalue \ 32 | redirectoutput right rnd round rtrim savekey sendkeys sendmessage setascii \ 33 | setconsole setdefaultprinter setfileattr setfocus setoption setsystemstate \ 34 | settitle setwallpaper showprogramgroup shutdown sidtoname split srnd substr \ 35 | trim ubound ucase unloadhive val vartype vartypename writeline \ 36 | writeprofilestring writevalue 37 | 38 | # This keywords are macros if preceded by @ 39 | keywords3.$(file.patterns.kix)=address build color comment cpu crlf csd curdir \ 40 | date day domain dos error fullname homedir homedrive homeshr hostname \ 41 | inwin ipaddress0 ipaddress1 ipaddress2 ipaddress3 kix lanroot ldomain \ 42 | ldrive lm logonmode longhomedir lserver maxpwage mdayno mhz monthno \ 43 | month msecs pid primarygroup priv productsuite producttype pwage ras \ 44 | result rserver scriptdir scriptexe scriptname serror sid site startdir \ 45 | syslang ticks time userid userlang wdayno wksta wuserid ydayno year 46 | 47 | # Comments 48 | comment.block.kix=; 49 | comment.block.at.line.start.kix=1 50 | 51 | # Kix Styles 52 | # White space 53 | style.kix.0=fore:#000000,$(font.vbs) 54 | # Comment 55 | style.kix.1=$(colour.code.comment.line),$(font.code.comment.line) 56 | # String 57 | style.kix.2=$(colour.string) 58 | style.kix.3=$(colour.string) 59 | # Number 60 | style.kix.4=$(colour.number) 61 | # Variables 62 | style.kix.5=fore:#B00040 63 | # Macro 64 | style.kix.6=$(colour.preproc) 65 | # Keyword 66 | style.kix.7=$(colour.keyword),bold 67 | # Function 68 | style.kix.8=$(colour.keyword) 69 | # Operator 70 | style.kix.9=$(colour.operator),bold 71 | # Stream comment 72 | style.kix.10=$(colour.code.comment.box),$(font.code.comment.box) 73 | # Identifier 74 | style.kix.31= 75 | 76 | # Commands 77 | command.go.*.kix=kix32 $(FileName) 78 | 79 | # Indenting 80 | tab.size.$(file.patterns.kix)=6 81 | indent.size.$(file.patterns.kix)=3 82 | use.tabs.$(file.patterns.kix)=1 83 | 84 | statement.indent.$(file.patterns.kix)=7 if else for do while function case 85 | -------------------------------------------------------------------------------- /src/latex.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for LaTeX files. 2 | 3 | file.patterns.latex=*.tex;*.sty 4 | 5 | filter.latex=LaTeX (tex sty)|$(file.patterns.latex)| 6 | 7 | *filter.latex=$(filter.latex) 8 | 9 | lexer.$(file.patterns.latex)=latex 10 | 11 | # LaTeX styles 12 | # White space 13 | style.latex.0=fore:#000000 14 | # Command 15 | style.latex.1=fore:#AA0000,bold 16 | # Tag Opening 17 | style.latex.2=fore:#880088,bold 18 | # Math Inline 19 | style.latex.3=fore:#0000FF 20 | # Comment 21 | style.latex.4=fore:#00AA00 22 | # Tag Closing 23 | style.latex.5=fore:#880088,bold 24 | # Math Block 25 | style.latex.6=fore:#0000AA 26 | # Comment Block 27 | style.latex.7=fore:#00AA00 28 | # Verbatim Segment 29 | style.latex.8=fore:#666666 30 | # Short Command 31 | style.latex.9=fore:#AA6600,bold 32 | # Special Char 33 | style.latex.10=fore:#AAAA00 34 | # Command optional argument 35 | style.latex.11=fore:#FF9900 36 | # Syntax error 37 | style.latex.12=fore:#ffffff,back:#ff0000 38 | 39 | command.compile.*.tex=latex $(FileNameExt) 40 | command.build.*.tex=dvips -f $(FileName).dvi > $(FileName).ps 41 | command.go.*.tex=dvips $(FileName).dvi 42 | 43 | command.name.0.*.tex=View 44 | command.0.*.tex=xdvi $(FileName).dvi 45 | command.name.1.*.tex=View PS 46 | command.1.*.tex=gv $(FileName).ps 47 | -------------------------------------------------------------------------------- /src/lexillaVersion.txt: -------------------------------------------------------------------------------- 1 | 540 -------------------------------------------------------------------------------- /src/lot.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for lot files. 2 | file.patterns.lot=*.lot 3 | 4 | filter.lot=Lot (lot)|$(file.patterns.lot)| 5 | 6 | *filter.lot=$(filter.lot) 7 | 8 | lexer.$(file.patterns.lot)=lot 9 | 10 | *language.lot=Lot|lot|| 11 | 12 | word.characters.$(file.patterns.lot)=$(chars.alpha)$(chars.numeric) 13 | 14 | # LOT FileStyles 15 | # Default 16 | style.lot.0=fore:#000000 17 | # header 18 | style.lot.1=back:#00F0FF,eolfilled 19 | # break 20 | style.lot.2=back:#FFFF00,eolfilled 21 | # set 22 | style.lot.3=fore:#FFFFFF,back:#0000FF,bold,eolfilled 23 | # pass 24 | style.lot.4=back:#00FF00,eolfilled 25 | # fail 26 | style.lot.5=back:#FF0000,eolfilled,bold 27 | # abort 28 | style.lot.6=back:#0000FF,bold,eolfilled 29 | -------------------------------------------------------------------------------- /src/lout.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Basser Lout files. 2 | # Based on Lout 3.35 [April 2007] 3 | # * to update keywords, see or diff externs.h 4 | 5 | file.patterns.lout=*.lt 6 | 7 | filter.lout=Lout (lt)|*.lt| 8 | 9 | *filter.lout=$(filter.lout) 10 | 11 | lexer.$(file.patterns.lout)=lout 12 | 13 | *language.lout=Lout|lt|| 14 | 15 | # @-prefixed keywords 16 | keywords.$(file.patterns.lout)= \ 17 | @OptGall @FontDef @Family @Face @Name @Metrics @ExtraMetrics \ 18 | @Mapping @Recode @Filter @FilterIn @FilterOut @FilterErr \ 19 | @Common @Rump @Meld @Insert @OneOf @Next @Plus @Minus @Wide \ 20 | @High @HShift @VShift @BeginHeaderComponent @EndHeaderComponent \ 21 | @SetHeaderComponent @ClearHeaderComponent @OneCol @OneRow \ 22 | @HMirror @VMirror @HScale @VScale @HCover @VCover @Scale \ 23 | @KernShrink @HContract @VContract @HLimited @VLimited @HExpand \ 24 | @VExpand @StartHVSpan @StartHSpan @StartVSpan @HSpan @VSpan \ 25 | @PAdjust @HAdjust @VAdjust @Rotate @Background @IncludeGraphic \ 26 | @SysIncludeGraphic @Graphic @LinkSource @LinkDest @URLLink \ 27 | @PlainGraphic @Verbatim @RawVerbatim @Case @Yield @BackEnd \ 28 | @Char @Font @Space @YUnit @ZUnit @Break @Underline @SetColour \ 29 | @SetColor @SetUnderlineColour @SetUnderlineColor @SetTexture \ 30 | @Outline @Language @CurrLang @CurrFamily @CurrFace @CurrYUnit \ 31 | @CurrZUnit @LEnv @@A @@B @@C @@D @@E @LClos @@V @LUse @LEO \ 32 | @Open @Use @NotRevealed @Tagged @Database @SysDatabase \ 33 | @Include @SysInclude @IncludeGraphicRepeated \ 34 | @SysIncludeGraphicRepeated @PrependGraphic @SysPrependGraphic \ 35 | @Target @Null @PageLabel @Galley @ForceGalley @LInput @Split \ 36 | @Tag @Key @Optimize @Merge @Enclose @Begin @End @Moment \ 37 | @Second @Minute @Hour @Day @Month @Year @Century @WeekDay \ 38 | @YearDay @DaylightSaving @SetContext @GetContext 39 | 40 | # symbols that are keywords (excluding braces) 41 | keywords2.$(file.patterns.lout)= &&& && & ^// ^/ ^|| ^| ^& // / || | 42 | 43 | # non-@-prefixed keywords 44 | keywords3.$(file.patterns.lout)= def langdef force horizontally into \ 45 | extend import export precedence associativity left right body macro \ 46 | named compulsory following preceding foll_or_prec now 47 | 48 | comment.block.lout=#~ 49 | 50 | indent.maintain.$(file.patterns.lout)=1 51 | 52 | # Lout styles 53 | 54 | # Default 55 | style.lout.32=$(font.base) 56 | # White space 57 | style.lout.0=fore:#808080 58 | # Comment 59 | style.lout.1=$(colour.code.comment.line),$(font.code.comment.line) 60 | # Number 61 | style.lout.2=$(colour.number) 62 | # Keyword (@-prefixed keywords) 63 | style.lout.3=$(colour.keyword),bold 64 | # Keyword2 (symbol keywords) 65 | style.lout.4=$(colour.keyword),bold 66 | # Keyword3 (non-@ keywords) 67 | style.lout.5=$(colour.keyword),bold 68 | # Keyword4 (user or library symbols) 69 | style.lout.6=$(colour.keyword) 70 | # Double quoted string 71 | style.lout.7=$(colour.string) 72 | # Operators 73 | style.lout.8=$(colour.operator),bold 74 | # Identifiers 75 | style.lout.9= 76 | # End of line where string is not closed 77 | style.lout.10=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 78 | # Braces are only matched in operator style 79 | braces.lout.style=8 80 | 81 | command.compile.$(file.patterns.lout)=lout "$(FileNameExt)" > "$(FileName).ps" 82 | command.build.$(file.patterns.lout)=make 83 | 84 | if PLAT_WIN 85 | command.go.$(file.patterns.lout)=gview "$(FileName).ps" 86 | 87 | if PLAT_GTK 88 | command.go.$(file.patterns.lout)=gview32 "$(FileName).ps" 89 | 90 | -------------------------------------------------------------------------------- /src/markdown.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Markdown files. 2 | 3 | file.patterns.markdown=*.md;*.markdown 4 | 5 | *source.patterns.markdown=$(file.patterns.markdown); 6 | 7 | filter.markdown=Markdown (md markdown)|$(file.patterns.markdown)| 8 | *filter.markdown=$(filter.markdown) 9 | 10 | lexer.$(file.patterns.markdown)=markdown 11 | 12 | *language.markdown=Markdo&wn|markdown|| 13 | 14 | #lexer.markdown.header.eolfill=1 15 | 16 | # SCE_MARKDOWN_DEFAULT: Regular text 17 | style.markdown.0= 18 | 19 | # SCE_MARKDOWN_LINE_BEGIN: Special, e.g. end-of-line codes if enabled 20 | style.markdown.1= 21 | 22 | # SCE_MARKDOWN_STRONG1: "**" - Strong emphasis (bold) 23 | style.markdown.2=fore:#224466,bold 24 | # SCE_MARKDOWN_STRONG2: "__" - Strong emphasis (bold) 25 | style.markdown.3=fore:#224466,bold 26 | 27 | # SCE_MARKDOWN_EM1: '*' - Emphasis (italic) 28 | style.markdown.4=fore:#663300,italics 29 | # SCE_MARKDOWN_EM2: '_' - Emphasis (italic) 30 | style.markdown.5=fore:#663300,italics 31 | 32 | # SCE_MARKDOWN_HEADER1: "#" - Level-one header 33 | style.markdown.6=fore:#5183C4,bold,$(font.monospace) 34 | # SCE_MARKDOWN_HEADER2: "##" - Level-two header 35 | style.markdown.7=fore:#5183C4,bold,$(font.monospace) 36 | # SCE_MARKDOWN_HEADER3: "###" - Level-three header 37 | style.markdown.8=fore:#5183C4,bold,$(font.monospace) 38 | # SCE_MARKDOWN_HEADER4: "####" - Level-four header 39 | style.markdown.9=fore:#5183C4,bold,$(font.monospace) 40 | # SCE_MARKDOWN_HEADER5: "#####" - Level-five header 41 | style.markdown.10=fore:#5183C4,bold,$(font.monospace) 42 | # SCE_MARKDOWN_HEADER6: "######" - Level-six header 43 | style.markdown.11=fore:#5183C4,bold,$(font.monospace) 44 | 45 | # SCE_MARKDOWN_PRECHAR: Prechar (up to three indent spaces, e.g. for a second-level list) 46 | style.markdown.12=back:#EEEEAA,fore:#000000 47 | 48 | # SCE_MARKDOWN_ULIST_ITEM: "- ", "* ", "+ " - Unordered list item 49 | style.markdown.13=fore:#555555 50 | # SCE_MARKDOWN_OLIST_ITEM: "1. " to "9. ", "#. " - Ordered list item 51 | style.markdown.14=fore:#555555 52 | 53 | # SCE_MARKDOWN_BLOCKQUOTE: "> " - Block quote 54 | style.markdown.15=fore:#000088 55 | 56 | # SCE_MARKDOWN_STRIKEOUT: "~~" - Strikeout 57 | style.markdown.16=back:#A9BA9D,fore:#18453B,$(font.monospace) 58 | 59 | # SCE_MARKDOWN_HRULE: "---", "***", "___" - Horizontal rule 60 | style.markdown.17=fore:#555555,bold,$(font.monospace) 61 | 62 | # SCE_MARKDOWN_LINK: "[]", "![]" - Link or image 63 | style.markdown.18=fore:#0000AA,underlined 64 | 65 | # SCE_MARKDOWN_CODE: '`' - Inline code 66 | style.markdown.19=back:#EEEEEE,fore:#000088,$(font.monospace) 67 | # SCE_MARKDOWN_CODE2: "``" - Inline code (quotes code containing a single backtick) 68 | style.markdown.20=back:#EEEEEE,fore:#000088,$(font.monospace) 69 | # SCE_MARKDOWN_CODEBK: "~~~" - Code block 70 | style.markdown.21=back:#EEEEEE,fore:#000088,$(font.monospace) 71 | -------------------------------------------------------------------------------- /src/maxima.properties: -------------------------------------------------------------------------------- 1 | # file : maxima.properties 2 | # version : 2 march 2018 3 | # author : Gunter Königsmann / www.physikbuch.de. 4 | # based on : tex.properties by Hans Hagen / PRAGMA ADE / www.pragma-ade.com 5 | 6 | # Maxima: patterns 7 | 8 | file.patterns.maxima=*.wxm;*.mac 9 | 10 | # filter to be checked/tested: 11 | 12 | filter.maxima=maxima (mac wxm)|$(file.patterns.maxima)| 13 | lexer.$(file.patterns.maxima)=maxima 14 | 15 | *language.maxima=Maxima|mac|| 16 | 17 | # maxima: highlighting 18 | 19 | # Operator 20 | style.maxima.0=fore:#2060d0 21 | # Command ending 22 | style.maxima.1=fore:#a0a0a0 23 | # Comment 24 | style.maxima.2=fore:#80ff80 25 | # Number 26 | style.maxima.3=fore:#8080FF 27 | # String 28 | style.maxima.4=fore:#808080 29 | # Command 30 | style.maxima.5=fore:#000000 31 | # Variable 32 | style.maxima.6=fore:#00007F 33 | #Unknown 34 | style.maxima.7=fore:#000000 35 | 36 | # Maxima: comments 37 | 38 | comment.stream.start.maxima=/* 39 | comment.stream.end.maxima=*/ 40 | comment.box.start.maxima=/* 41 | comment.box.middle.maxima= * 42 | comment.box.end.maxima= */ 43 | 44 | # maxima: end of file -------------------------------------------------------------------------------- /src/mmixal.properties: -------------------------------------------------------------------------------- 1 | 2 | # Define SciTE settings for MMIXAL files. 3 | 4 | file.patterns.mmixal=*.mms 5 | filter.mmixal=MMIXAL (mms)|$(file.patterns.mmixal)| 6 | *filter.mmixal=$(filter.mmixal) 7 | 8 | lexer.$(file.patterns.mmixal)=mmixal 9 | 10 | *language.mmixal=MMIXAL|mms|| 11 | 12 | opcodes=2ADDU 4ADDU 8ADDU 16ADDU ADD ADDU AND ANDNH ANDNL ANDNMH ANDNML \ 13 | BDIF BEV BN BNN BNP BNZ BOD BP BSPEC BYTE BZ CMP CMPU CSEV CSN CSNN CSNP CSNZ CSOD CSP CSWAP CSZ \ 14 | DIV DIVU ESPEC EXPR FADD FCMP FCMPE FDIV FEQL FEQLE FIX FIXU FLOT FLOTU FMUL FREM FSQRT FSUB FUN FUNE \ 15 | GET GETA GO GREG I_BIT INCH INCL INCMH INCML IS JMP LDA LDB LDBU LDHT LDO LDOU LDSF LDT LDTU LDUNC LDVTS LDW LDWU LOC LOCAL \ 16 | MOR MUL MULU MUX MXOR NAND NEG NEGU NNIX NOR NXOR O_BIT OCTA ODIF OR ORH ORL ORMH ORML ORN \ 17 | PBEV PBN PBNN PBNP PBNZ PBOD PBP PBZ POP PREFIX PREGO PRELD PREST PUSHGO PUSHJ PUT \ 18 | RESUME SAVE SET SETH SETL SETMH SETML SFLOT SFLOTU SL SLU SR SRU \ 19 | STB STBU STCO STHT STO STOU STSF STT STTU STUNC STW STWU SUB SUBU SWYM SYNC SYNCD TDIF TETRA TRAP TRIP UNSAVE \ 20 | WDIF WYDEXOR ZSEV ZSN ZSNN ZSNP ZSNZ ZSOD ZSP ZSZ 21 | 22 | special_register=rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP rQ rR rS rT rU rV rW rX rY rZ rBB rTT rWW rXX rYY rZZ 23 | 24 | predef_symbols=@ Text_Segment Data_Segment Pool_Segment Stack_Segment \ 25 | StdErr StdIn StdOut \ 26 | Fopen Fclose Fread Fwrite Fgets Fputs Fgetws Fputws Ftell Fseek \ 27 | TextRead TextWrite BinaryRead BinaryWrite BinaryReadWrite 28 | 29 | keywords.$(file.patterns.mmixal)=$(opcodes) 30 | keywords2.$(file.patterns.mmixal)=$(special_register) 31 | keywords3.$(file.patterns.mmixal)=$(predef_symbols) 32 | 33 | # Divsion of leading whitespace in line 34 | style.mmixal.0= 35 | # Comment 36 | style.mmixal.1=$(colour.code.comment.line),$(font.code.comment.line) 37 | # Label 38 | style.mmixal.2=$(font.base) 39 | # Opcode (not validated) 40 | style.mmixal.3= 41 | # Division between Label and Opcode 42 | style.mmixal.4= 43 | # Valid Opcode (as defined in opcodes above) 44 | style.mmixal.5=$(colour.keyword),bold 45 | # Unknown Opcode 46 | style.mmixal.6=$(colour.error) 47 | # Division between Opcode and Operands 48 | style.mmixal.7= 49 | # Division of Operands 50 | style.mmixal.8= 51 | # Number 52 | style.mmixal.9=$(colour.number) 53 | # Reference (to a Label) 54 | style.mmixal.10=$(font.base) 55 | # Char 56 | style.mmixal.11=$(colour.char) 57 | # String 58 | style.mmixal.12=$(colour.string) 59 | # Register (also special_register as defined above) 60 | style.mmixal.13=fore:#7F007F 61 | # Hexadecimal Number 62 | style.mmixal.14=fore:#7F0000 63 | # Operator 64 | style.mmixal.15=bold 65 | # Symbol (as defined in predef_symbols above) 66 | style.mmixal.16=fore:#FF7777 67 | # Include for those who use the preprocessor mmixali written by R. Loos. 68 | # Comment otherwise. 69 | #~ style.mmixal.17=$(colour.preproc) 70 | style.mmixal.17=$(colour.code.comment.line),$(font.code.comment.line) 71 | 72 | comment.block.mmixal=% 73 | 74 | tab.size.$(file.patterns.mmixal)=16 75 | indent.size.$(file.patterns.mmixal)=16 76 | 77 | command.compile.$(file.patterns.mmixal)=mmixal -l $(FileName).map -b 200 $(FilePath) 78 | command.go.$(file.patterns.mmixal)=mmix $(1) $(FileName).mmo 79 | #~ mmotype 80 | command.name.2.$(file.patterns.mmixal)=mmotype 81 | command.2.$(file.patterns.mmixal)=mmotype $(FileName).mmo $(FileName).out 82 | -------------------------------------------------------------------------------- /src/nim.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Nim files. 2 | 3 | # File filters, patterns, language, lexer and source 4 | file.patterns.nim=*.nim 5 | filter.nim=Nim (nim)|$(file.patterns.nim)| 6 | lexer.$(file.patterns.nim)=nim 7 | 8 | *filter.nim=$(filter.nim) 9 | *language.nim=Nim|nim|| 10 | *source.patterns.nim=$(file.patterns.nim); 11 | 12 | # Primary keywords 13 | keywords.$(file.patterns.nim)=addr and as asm bind block break case cast concept \ 14 | const continue converter defer discard distinct div do elif else end enum \ 15 | except export finally for from func if import in include interface is \ 16 | isnot iterator let macro method mixin mod nil not notin object of or out \ 17 | proc ptr raise ref return shl shr static template try tuple type \ 18 | using var when while xor yield 19 | 20 | # Auto indentation 21 | statement.indent.$(file.patterns.nim)=15 : 22 | #statement.indent.$(file.patterns.nim)=8 block elif else except finally of for \ 23 | #if iterator macro proc template try while 24 | statement.lookback.$(file.patterns.nim)=0 25 | 26 | # Indent view 27 | view.indentation.examine.*.nim=2 28 | 29 | # Determines if generalized raw string Identifiers should have the same color as 30 | # their corresponding string literal 31 | lexer.nim.raw.strings.highlight.ident=0 32 | 33 | # Comment insertion 34 | comment.block.nim=# 35 | comment.stream.start.nim=#[ 36 | comment.stream.end.nim=]# 37 | comment.box.start.nim=#[ 38 | comment.box.middle.nim= # 39 | comment.box.end.nim=]# 40 | 41 | # Lexer styling 42 | # White space/default 43 | style.nim.0=fore:#808080 44 | # Comment block 45 | style.nim.1=fore:#007F00,$(font.comment) 46 | # Comment block (doc) 47 | style.nim.2=fore:#0000FF,$(font.comment) 48 | # Comment line 49 | style.nim.3=fore:#007F00,$(font.comment) 50 | # Comment line (doc) 51 | style.nim.4=fore:#D73A49,$(font.comment) 52 | # Number 53 | style.nim.5=fore:#007F7F 54 | # String 55 | style.nim.6=fore:#7F007F 56 | # Character 57 | style.nim.7=fore:#7F007F 58 | # Word 59 | style.nim.8=fore:#00007F,bold 60 | # Triple 61 | style.nim.9=fore:#7F0000 62 | # Triple double 63 | style.nim.10=fore:#7F0000 64 | # Backticks 65 | style.nim.11=fore:#000000 66 | # Function name (eg. after proc, macro, template, etc.) 67 | style.nim.12=fore:#007F7F,bold 68 | # End of line where string is not closed 69 | style.nim.13=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 70 | # Numeric format error (eg. when a binary value is incorrect, like 0b1510) 71 | style.nim.14=fore:#000000,back:#FF8080 72 | # Operator 73 | style.nim.15=bold 74 | # Identifier 75 | style.nim.16=fore:#000000 76 | 77 | # Nim Compiler User Guide: 78 | # https://nim-lang.org/docs/nimc.html 79 | if PLAT_WIN 80 | command.go.$(file.patterns.nim)=nim c -r "$(FileNameExt)" 81 | command.go.subsystem.$(file.patterns.nim)=1 82 | 83 | if PLAT_GTK 84 | command.go.$(file.patterns.nim)=nim c -r "$(FileNameExt)" 85 | 86 | command.compile.$(file.patterns.nim)=nim c "$(FilePath)" 87 | command.help.$(file.patterns.nim)=nim -h 88 | 89 | # Add command to Tools menu 90 | command.name.1.$(file.patterns.nim)=Compile Release Version 91 | command.1.$(file.patterns.nim)=nim c -d:release "$(FileNameExt)" 92 | -------------------------------------------------------------------------------- /src/opal.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Opal files. 2 | 3 | filter.opal=OPAL (impl sign)|*.impl;*.sign| 4 | 5 | *filter.opal=$(filter.opal) 6 | 7 | file.patterns.opal=*.impl;*.sign 8 | lexer.$(file.patterns.opal)=opal 9 | *language.opal=Opal|impl|| 10 | 11 | keywordclass.opal_keywords=ALL AND ANDIF ANY AS ASSERT AXM COMPLETELY DATA DEF DERIVE \ 12 | DFD DISCRIMINATORS ELSE EX EXTERNAL FI FIX FUN IF IMPLEMENTATION IMPLIES IMPORT \ 13 | IN INHERIT INJECTIONS INTERFACE INTERNAL LAW LAZY LEFTASSOC LET MODULE NOT ONLY \ 14 | OR ORIF OTHERWISE POST PRE PRED PRIORITY PROPERTIES REALIZES REQUIRE RIGHTASSOC \ 15 | SELECTORS SIGNATURE SORT SPC SPEC SPECIFICATION STRUCTURE THE THEN THEORY THM \ 16 | TYPE UNIQ WHERE 17 | 18 | keywordclass.opal_sorts=aEntry agent align anchor ans arg arg1 arg2 array \ 19 | arrowWhere bag bitmap bool bstree byte callback canvasEditor capStyle channel \ 20 | char childstat codom codomFrom codomTo color colorModel com composeOp config \ 21 | configCom cursor dArray data data1 data11 data2 data21 data3 data31 data4 \ 22 | data41 dataFrom dataTo defaultPrio denotation device dist distOut dom domFrom \ 23 | domTo drawing dyn emitter env event eventInfo file filemode filestat filetype \ 24 | first first1 first2 first3 fission fmt font from from1 from2 funct group groupid \ 25 | heap iconfig image in inData index inode input int inter interdom interpreter \ 26 | iseq items joinStyle justifyHow long manager managerRequest map mapEntry mark \ 27 | mid modifier nat natMap OBJECT option orient out outData output packOp pair \ 28 | parser permission point positionRequest process procstat quad range real \ 29 | regulator rel relief res res1 res2 result role sap script scroller scrollView \ 30 | scrollWindow searchOpt second seekMode selector semaphor seq seqEntry set \ 31 | setEntry short sigaction sighandler sigmask signal size sizeRequest some \ 32 | sreal state stateId stateRequest string subrel tag textEditor time to tree \ 33 | triple union user userid version view void wconfig wconfigCom wday widget \ 34 | window wrapStyle 35 | 36 | keywords.$(file.patterns.opal)=$(keywordclass.opal_keywords) 37 | keywords2.$(file.patterns.opal)=$(keywordclass.opal_sorts) 38 | 39 | 40 | # Opal styles 41 | # White space 42 | style.opal.0=fore:#000000,$(font.opal) 43 | # Comment block 44 | style.opal.1=fore:#007F00,italics,$(font.comment) 45 | # Comment line 46 | style.opal.2=fore:#007F00,italics,$(font.comment) 47 | # Integer 48 | style.opal.3=fore:#007F7F 49 | # Keyword 50 | style.opal.4=fore:#00007F,bold 51 | # Sort 52 | style.opal.5=fore:#007F7F 53 | # Double quoted string 54 | style.opal.6=fore:#7F007F,italics,$(font.comment) 55 | # Brace normal 56 | style.opal.7=fore:#000000 57 | # Bool const 58 | style.opal.8=fore:#A00000 59 | 60 | # Default/Identifiers 61 | style.opal.32=fore:#000000 62 | # Brace highlight 63 | style.opal.34=fore:#FF0000,back:#FFFF00,bold 64 | # Brace incomplete highlight 65 | style.opal.35=fore:#FF0000,back:#00FF00,bold 66 | -------------------------------------------------------------------------------- /src/powerpro.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for powerpro files. 2 | file.patterns.powerpro=*.powerpro 3 | 4 | filter.powerpro=PowerPro (powerpro)|$(file.patterns.powerpro)| 5 | *filter.powerpro=$(filter.powerpro) 6 | lexer.$(file.patterns.powerpro)=powerpro 7 | *language.powerpro=PowerPro|powerpro|| 8 | 9 | keywordclass.control=\ 10 | break do else elseif endfor endif for function global gt if ifelse \ 11 | ifx jump local lt quit static 12 | 13 | keywords.$(file.patterns.powerpro)=$(keywordclass.control) 14 | 15 | keywordclass.plugins=\ 16 | win.debug win.debugshow win.exists win.getdisplayrect win.getfocus win.gethandle win.getrect \ 17 | win.getsystemmetrics win.gettext win.maximize win.minimize win.move win.sendkeys win.setdebug \ 18 | win.setfocus win.setrect win.settext win.show 19 | 20 | keywordclass.functions=\ 21 | bar case clip env exec fill flag floattostring format formattime ftos \ 22 | index input inputcancel inputdefault inputdialog join length messagebox mouse \ 23 | not note readline remove replace replacechars replaceg revindex select \ 24 | stof validpath visiblewindow wait wait.activity wait.for wait.forinterval wait.message \ 25 | wait.quit wait.ready wait.sleep wait.until wallpaper window window word 26 | 27 | keywords2.$(file.patterns.powerpro)=$(keywordclass.plugins)|$(keywordclass.functions) 28 | 29 | calltip.powerpro.word.characters=$(chars.alpha)$(chars.numeric)_ 30 | comment.block.powerpro=//~ 31 | comment.stream.start.powerpro=/* 32 | comment.stream.end.powerpro=*/ 33 | comment.box.start.powerpro=/* 34 | comment.box.middle.powerpro= * 35 | comment.box.end.powerpro= */ 36 | 37 | # Autocomplete and call tip settings 38 | #api.*.powerpro=$(SciteDefaultHome)\api\powerpro.api 39 | word.characters.*.powerpro=$(chars.alpha)$(chars.numeric)@$_ 40 | 41 | # Default 42 | style.powerpro.32=$(font.base) 43 | # Default text color 44 | style.powerpro.0=#fore:$(font.base) 45 | # Comment: /* */ 46 | style.powerpro.1=$(colour.code.comment.box),$(font.code.comment.box) 47 | # Line Comment: // ;; ; 48 | style.powerpro.2=$(colour.code.comment.line),$(font.code.comment.line) 49 | # Number 50 | style.powerpro.3=$(colour.number) 51 | # Keywords1 52 | #style.powerpro.4=$(colour.keyword),bold 53 | style.powerpro.4=fore:#0000FF 54 | # Keywords2 55 | style.powerpro.5=fore:#B00040 56 | # Keywords3 57 | style.powerpro.6=fore:#0000FF 58 | # Keywords4 59 | style.powerpro.7=fore:#0000FF 60 | # Double quoted string 61 | style.powerpro.8=$(colour.string) 62 | # Single quoted string 63 | style.powerpro.9=$(colour.char) 64 | # Line continuation 65 | style.powerpro.10=$(colour.preproc) 66 | # Operators 67 | style.powerpro.11=$(colour.operator),bold 68 | # Braces are only matched in operator style 69 | braces.powerpro.style=11 70 | # Identifiers 71 | style.powerpro.12=#0000FF 72 | # End of line where string is not closed 73 | style.powerpro.13=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 74 | # Verbatim strings 75 | style.powerpro.14=$(colour.char) 76 | #alternate quote style (#) 77 | style.powerpro.15=$(colour.string) 78 | #function style 79 | style.powerpro.16=fore:#B00040,bold 80 | 81 | 82 | command.go.$(file.patterns.powerpro)="$(FilePath)" 83 | command.go.subsystem.$(file.patterns.powerpro)=2 84 | 85 | command.help.$(file.patterns.powerpro)=$(CurrentWord)!C:\Program Files\PowerPro\powerpro.chm 86 | command.help.subsystem.$(file.patterns.powerpro)=4 87 | -------------------------------------------------------------------------------- /src/purebasic.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for PureBasic files. 2 | 3 | file.patterns.purebasic=*.pb 4 | 5 | filter.purebasic=PureBasic (pb)|$(file.patterns.purebasic)| 6 | 7 | *filter.purebasic=$(filter.purebasic) 8 | 9 | lexer.$(file.patterns.purebasic)=purebasic 10 | 11 | # keywords must be all lowercase 12 | 13 | #Language 14 | keywords.$(file.patterns.purebasic)=and break case continue data \ 15 | datasection declare declarecdll declaredll default deftype dim else \ 16 | elseif end enddatasection endenumeration endif endinterface endprocedure \ 17 | endselect endstructure endstructureunion enumeration extends fakereturn \ 18 | for foreach forever global gosub goto if includebinary includefile \ 19 | includepath interface newlist next or procedure procedurecdll \ 20 | proceduredll procedurereturn protected read repeat restore return select \ 21 | shared static step structure structureunion to until wend while xincludefile 22 | 23 | #preprocessor 24 | keywords2.$(file.patterns.purebasic)=compilercase compilerdefault \ 25 | compilerelse compilerendif compilerendselect compilerif compilerselect 26 | 27 | #fold.basic.comment.explicit=1 28 | #fold.basic.explicit.anywhere=1 29 | #fold.basic.explicit.end=;[[ 30 | #fold.basic.explicit.start=;]] 31 | #fold.basic.syntax.based=0 32 | 33 | # PB styles 34 | # Default 35 | style.purebasic.0=fore:#000000 36 | # Comment 37 | style.purebasic.1=$(colour.code.comment.line),$(font.code.comment.line) 38 | # Number 39 | style.purebasic.2=$(colour.number) 40 | # Keyword1 41 | style.purebasic.3=$(colour.keyword) 42 | # String 43 | style.purebasic.4=$(colour.string) 44 | # Preprocessor 45 | # style.purebasic.5=$(colour.error) 46 | # Operator 47 | style.purebasic.6=$(colour.operator) 48 | # Identifier 49 | style.purebasic.7=$(style.purebasic.0) 50 | # Date 51 | # style.purebasic.8=$(colour.error) 52 | # StringEOL 53 | # style.purebasic.9=$(colour.error) 54 | # Keyword2 55 | style.purebasic.10=$(colour.preproc) 56 | # Keyword3 57 | style.purebasic.11=$(colour.keyword) 58 | # Keyword4 59 | style.purebasic.12=$(colour.keyword) 60 | # Constant 61 | style.purebasic.13=$(colour.number) 62 | # Asm 63 | # style.purebasic.14=$(colour.error) 64 | # Label 65 | style.purebasic.15=$(colour.preproc) 66 | # Error 67 | style.purebasic.16=$(colour.error) 68 | # HexNumber 69 | style.purebasic.17=$(colour.number) 70 | # BinNumber 71 | style.purebasic.18=$(colour.number) 72 | 73 | -------------------------------------------------------------------------------- /src/rebol.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/src/rebol.properties -------------------------------------------------------------------------------- /src/registry.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for registry files. 2 | 3 | file.patterns.registry=*.reg 4 | filter.registry=Registration files (reg)|$(file.patterns.registry)| 5 | lexer.$(file.patterns.registry)=registry 6 | 7 | comment.block.registry=;; 8 | 9 | [Styles] 10 | 11 | style.registry.32=$(font.text) 12 | # Default 13 | style.registry.0=fore:#000000 14 | # Comment: ;; 15 | style.registry.1=$(colour.code.comment.line) 16 | # Value name: "Icon"="cmd.exe,-1" 17 | style.registry.2=fore:#0000FF 18 | # String 19 | style.registry.3=$(colour.string) 20 | # Hex digit 21 | style.registry.4=fore:#7F0B0C 22 | # Value type: dword, hex(2), hex(7) 23 | style.registry.5=fore:#00007F,bold 24 | # Added key, [HKLM\*\shell\notepad] 25 | style.registry.6=fore:#530155 26 | # Removed key, [-HKLM\*\shell\notepad] 27 | style.registry.7=fore:#FF0000 28 | # Escaped characters in strings 29 | style.registry.8=fore:#7D8187,bold 30 | # GUID in key path, [HKCU\{C4ACBD3E-6114-4618-904C-B206ABA9DEB0}] 31 | style.registry.9=fore:#7B5F15 32 | # GUID in string, @="{C4ACBD3E-6114-4618-904C-B206ABA9DEB0}" 33 | style.registry.10=$(style.registry.9) 34 | # Parameter: "notepad.exe %1 %*" 35 | style.registry.11=fore:#0B6561 36 | # Operators 37 | style.registry.12=bold 38 | -------------------------------------------------------------------------------- /src/rust.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Rust 2 | 3 | file.patterns.rust=*.rs 4 | filter.rust=Rust (rs)|$(file.patterns.rust)| 5 | *filter.rust=$(filter.rust) 6 | lexer.$(file.patterns.rust)=rust 7 | *language.rust=Rust|rs|| 8 | 9 | word.chars.rust=$(chars.alpha)$(chars.numeric)_# 10 | word.characters.$(file.patterns.rust)=$(word.chars.rust) 11 | calltip.rust.word.characters=$(chars.alpha)$(chars.numeric)_ 12 | 13 | comment.block.at.line.start.rust=1 14 | comment.block.rust=//~ 15 | comment.stream.start.rust=/* 16 | comment.stream.end.rust=*/ 17 | comment.box.start.rust=/* 18 | comment.box.middle.rust= * 19 | comment.box.end.rust= */ 20 | 21 | statement.indent.$(file.patterns.rust)=6 22 | statement.end.$(file.patterns.rust)=16 ; 23 | statement.lookback.$(file.patterns.rust)=20 24 | block.start.$(file.patterns.rust)=16 { 25 | block.end.$(file.patterns.rust)=16 } 26 | braces.rust.style=16 27 | 28 | # Rust keywords 29 | keywords.$(file.patterns.rust)=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 30 | 31 | # Built-in types 32 | keywords2.$(file.patterns.rust)=bool char f32 f64 i16 i32 i64 i8 int str u16 u32 u64 u8 uint 33 | 34 | # The Self parameter 35 | keywords3.$(file.patterns.rust)=Self 36 | 37 | #fold.rust.comment.explicit=0 38 | #fold.rust.comment.multiline=0 39 | #fold.rust.explicit.anywhere=1 40 | #fold.rust.explicit.end=//[[ 41 | #fold.rust.explicit.start=//]] 42 | #fold.rust.syntax.based=0 43 | 44 | # Styles 45 | 46 | style.rust.32=$(font.base) 47 | # Whitespace 48 | style.rust.0=fore:#808080 49 | # Block comment 50 | style.rust.1=$(colour.code.comment.box),$(font.code.comment.box) 51 | # Line comment 52 | style.rust.2=$(colour.code.comment.line),$(font.code.comment.line) 53 | # Block doc comment 54 | style.rust.3=$(colour.code.comment.doc),$(font.code.comment.doc) 55 | # Line doc comment 56 | style.rust.4=$(colour.code.comment.doc),$(font.code.comment.doc) 57 | # Number 58 | style.rust.5=$(colour.number) 59 | # Keywords 1-7 60 | style.rust.6=$(colour.keyword),bold 61 | style.rust.7=$(colour.keyword),bold 62 | style.rust.8=$(colour.keyword) 63 | style.rust.9=$(colour.keyword),bold 64 | style.rust.10=$(colour.keyword),bold 65 | style.rust.11=$(colour.keyword),bold 66 | style.rust.12=$(colour.keyword),bold 67 | # Regular string 68 | style.rust.13=$(colour.string) 69 | # Raw string 70 | style.rust.14=fore:#B090B0 71 | # Character 72 | style.rust.15=$(colour.char) 73 | # Operator 74 | style.rust.16=$(colour.operator),bold 75 | # Identifier 76 | style.rust.17= 77 | # Lifetime 78 | style.rust.18=fore:#007F7F 79 | # Macro 80 | style.rust.19=$(colour.preproc) 81 | # Lexical error 82 | style.rust.20=fore:#000000,$(font.monospace),back:#E0C0E0 83 | # Byte string 84 | style.rust.21=$(colour.string) 85 | # Raw byte string 86 | style.rust.22=fore:#B090B0 87 | # Byte character 88 | style.rust.23=$(colour.char) 89 | 90 | command.compile.*.rs=rustc $(FileNameExt) 91 | command.build.*.rs=$(make.command) 92 | command.go.*.rs=./$(FileName) 93 | 94 | -------------------------------------------------------------------------------- /src/sas.properties: -------------------------------------------------------------------------------- 1 | # FIXME: The keyword lists are not complete. I don't know 2 | # enough SAS to fill them sensibly. -- Dejan 3 | # ------ 4 | 5 | ### USER INTERFACE 6 | 7 | file.patterns.sas=*.sas; 8 | 9 | *source.patterns.sas=$(file.patterns.sas); 10 | 11 | filter.sas=SAS (sas)|$(file.patterns.sas)| 12 | 13 | lexer.$(file.patterns.sas)=sas 14 | 15 | *language.sas=&SAS|sas|| 16 | 17 | 18 | ### KEYWORD LISTS (Are they used ?) 19 | 20 | # Keywords 21 | keywords.$(file.patterns.sas)=%let %do 22 | 23 | # Block Keywords 24 | keywords2.$(file.patterns.sas)=also cards class data input model ods proc var where 25 | 26 | # Function Keywords 27 | keywords3.$(file.patterns.sas)=%printz 28 | 29 | # Statement Keywords 30 | keywords4.$(file.patterns.sas)=run 31 | 32 | 33 | ### AUTO-COMMENT (see "Edit" Menu) 34 | 35 | ## SAS has three kinds of block comment and no stream comment. 36 | 37 | ## Choose a style for BLOCK comments. 38 | 39 | # STYLE 1: * ... ; 40 | comment.stream.start.sas=* 41 | comment.stream.end.sas=; 42 | 43 | # STYLE 3: // ... ; 44 | # comment.stream.start.sas=// 45 | # comment.stream.end.sas=; 46 | 47 | # STYLE 3: /* ... */ 48 | # comment.stream.start.sas=/* 49 | # comment.stream.end.sas=*/ 50 | 51 | 52 | # Choose a style for BOX comments (Ctrl+Shift+B). Note that 53 | # you can leave box.middle empty by setting it to a single 54 | # whitespace before the newline. 55 | 56 | # STYLE 1: * ... * ... ; 57 | comment.box.start.sas=* 58 | comment.box.middle.sas=* 59 | comment.box.end.sas=; 60 | 61 | # STYLE 2: // ... // ... ; 62 | # comment.box.start.sas=// 63 | # comment.box.middle.sas=// 64 | # comment.box.end.sas=; 65 | 66 | # STYLE 3: /* ... * ... */ 67 | # comment.box.start.sas=/* 68 | # comment.box.middle.sas=* 69 | # comment.box.end.sas=*/ 70 | 71 | 72 | ### STYLES 73 | 74 | # Default 75 | style.sas.0= 76 | 77 | # Comment (* ... ;) 78 | style.sas.1=$(colour.code.comment.box),$(font.code.comment.box) 79 | 80 | # Comment Line (// ... ;) 81 | style.sas.2=$(colour.code.comment.line),$(font.code.comment.line) 82 | 83 | # Comment Block (/* ... */) 84 | style.sas.3=$(colour.code.comment.box),$(font.code.comment.box) 85 | 86 | # Numbers 87 | style.sas.4=$(colour.number) 88 | 89 | # Operators 90 | style.sas.5=$(colour.operator),bold 91 | 92 | # Identifier 93 | style.sas.6=fore:#000000 94 | 95 | # String 96 | style.sas.7=$(colour.string) 97 | 98 | # Types (not implemented yet) 99 | # style.sas.8= 100 | 101 | # Words (not implemented yet) 102 | # style.sas.9= 103 | 104 | # Global Macro (not implemented yet) 105 | # style.sas.10= 106 | 107 | # Macro (words that start with %) 108 | style.sas.11=fore:#CC66FF,bold 109 | 110 | # Macro Keywords (see "keywords." above) 111 | style.sas.12=fore:#CC66FF 112 | 113 | # Block Keywords (see "keywords2." above) 114 | style.sas.13=fore:#000080,bold 115 | 116 | # Macro Function Keywords (see "keywords3." above) 117 | style.sas.14=fore:#FF66FF,bold 118 | 119 | # Statement Keywords (see "keywords4." above) 120 | style.sas.15=fore:#AA0000,bold 121 | -------------------------------------------------------------------------------- /src/scintillaVersion.txt: -------------------------------------------------------------------------------- 1 | 552 -------------------------------------------------------------------------------- /src/scite_lua_win.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file scite_lua_win.h 3 | ** SciTE Lua scripting interface. 4 | **/ 5 | // Copyright 2010 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef SCITE_LUA_WIN_H 9 | #define SCITE_LUA_WIN_H 10 | 11 | /* Modifications for Windows to allow UTF-8 file names and command lines */ 12 | /* 13 | Imported into Lua build with -DLUA_USER_H=\"scite_lua_win.h\" 14 | Redirect fopen and _popen to functions that treat their arguments as UTF-8. 15 | If UTF-8 does not work then retry with the original strings as may be in locale characters. 16 | */ 17 | #if defined(LUA_USE_WINDOWS) 18 | #include 19 | FILE *scite_lua_fopen(const char *filename, const char *mode); 20 | #define fopen scite_lua_fopen 21 | FILE *scite_lua_popen(const char *filename, const char *mode); 22 | #define _popen scite_lua_popen 23 | #endif 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/scriptol.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for scriptol files. 2 | 3 | filter.scriptol=Scriptol (sol)|*.sol| 4 | 5 | *filter.scriptol=$(filter.scriptol) 6 | 7 | lexer.*.sol=scriptol 8 | 9 | file.patterns.sol=*.sol 10 | 11 | keywordclass.scriptol= act action alias always and array as \ 12 | bool boolean break by byte \ 13 | class case catch const constant continue \ 14 | dyn def define dict do double \ 15 | echo else elsif end enum error false file for float forever function \ 16 | globak gtk \ 17 | in if ifdef import include int integer java javax \ 18 | let long match mod nil not natural null number \ 19 | or print protected public real return redo \ 20 | scan script scriptol sol short super static step until using \ 21 | var text then this true try \ 22 | void volatile while when \ 23 | undef zero 24 | keywords.$(file.patterns.sol)=$(keywordclass.scriptol) 25 | 26 | statement.indent.*.sol= 27 | statement.lookback.*.sol=1 28 | block.start.*.sol=10 29 | 30 | comment.block.scriptol=`~ 31 | 32 | # scriptol styles 33 | # Default 34 | style.scriptol.0=fore:#000000 35 | # White space 36 | style.scriptol.1=fore:#808080 37 | # Scriptol style comment line 38 | style.scriptol.2=fore:#007F00,$(font.comment) 39 | # Persistent comment line 40 | style.scriptol.3=fore:#007F00,$(font.comment) 41 | # C style comment line 42 | style.scriptol.4=fore:#007F00 43 | # Comment-blocks 44 | style.scriptol.5=fore:#007F00,$(font.comment) 45 | # Number 46 | style.scriptol.6=fore:#007F7F 47 | # String 48 | style.scriptol.7=fore:#7F007F,$(font.monospace) 49 | # Character/Single quoted string 50 | style.scriptol.8=fore:#7F007F,$(font.monospace) 51 | # End of line where string is not closed 52 | style.scriptol.9=fore:#FF0000,$(font.monospace),back:#E0C0E0,eolfilled 53 | # Keyword 54 | style.scriptol.10=fore:#00007F,bold 55 | # Operators 56 | style.scriptol.11=bold 57 | # Identifiers 58 | style.scriptol.12=fore:#333333 59 | # Triple quotes 60 | style.scriptol.13= 61 | # style.scriptol.13=fore:#007F00 62 | # Class name definition 63 | style.scriptol.14=fore:#0000FF,bold 64 | # Preprocessor 65 | style.scriptol.15= 66 | # style.scriptol.15=fore:#7F0000 67 | 68 | 69 | if PLAT_WIN 70 | command.help.$(file.patterns.sol)="file://$(SciteDefaultHome)\manual.html" 71 | command.help.subsystem.$(file.patterns.sol)=2 72 | 73 | if PLAT_GTK 74 | command.help.$(file.patterns.sol)=man $(CurrentWord) | col -b 75 | 76 | command.compile.*.sol=solc -c $(FileNameExt) 77 | command.build.*.sol=solc -be $(FileNameExt) 78 | command.go.*.sol=$(FileName) 79 | command.go.subsystem.*.sol=1 80 | 81 | command.name.0.*.sol=XSolP 82 | command.0.*.sol =xsolp -be $(FileNameExt) 83 | command.is.filter.0.*.sol=1 84 | 85 | command.name.1.*.sol=XSolC 86 | command.1.*.sol =xsolc -be $(FileNameExt) 87 | command.is.filter.1.*.sol=1 88 | 89 | command.name.2.*.sol=Compile to Php 90 | command.2.*.sol=solp -b $(FileNameExt) 91 | command.is.filter.2.*.sol=1 92 | 93 | command.name.3.*.sol=Compile Web page 94 | command.3.*.sol=solp -b -w $(FileNameExt) 95 | command.is.filter.3.*.sol=1 96 | 97 | command.name.4.*.sol=Interpret 98 | command.4.*.sol=solp $(FileNameExt) 99 | command.is.filter.4.*.sol=1 100 | 101 | -------------------------------------------------------------------------------- /src/smalltalk.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for Smalltalk files. 2 | 3 | file.patterns.smalltalk=*.st 4 | 5 | filter.smalltalk=Smalltalk (st)|$(file.patterns.smalltalk)| 6 | 7 | *filter.smalltalk=$(filter.smalltalk) 8 | 9 | lexer.$(file.patterns.smalltalk)=smalltalk 10 | 11 | keywords.$(file.patterns.smalltalk)=\ 12 | ifTrue: ifFalse: whileTrue: whileFalse: ifNil: ifNotNil: whileTrue whileFalse repeat isNil notNil 13 | 14 | # Styles 15 | 16 | # Default 17 | style.smalltalk.0= 18 | # String 19 | style.smalltalk.1=$(colour.string),eolfilled 20 | # Number 21 | style.smalltalk.2=$(colour.number) 22 | # Comment 23 | style.smalltalk.3=$(colour.code.comment.box) 24 | # Symbol 25 | style.smalltalk.4=fore:#800080 26 | # Binary 27 | style.smalltalk.5=$(colour.operator) 28 | # Boolean 29 | style.smalltalk.6=$(colour.keyword),bold 30 | # self 31 | style.smalltalk.7=$(colour.keyword),bold 32 | # super 33 | style.smalltalk.8=$(colour.keyword),bold 34 | # nil 35 | style.smalltalk.9=$(colour.keyword),bold 36 | # Global 37 | style.smalltalk.10=bold 38 | # Return 39 | style.smalltalk.11=fore:#A00000,bold 40 | # Special 41 | style.smalltalk.12=bold 42 | # KwSend 43 | style.smalltalk.13=fore:#008000 44 | # Assignment 45 | style.smalltalk.14=bold 46 | # Character 47 | style.smalltalk.15=$(colour.char) 48 | # Special selector 49 | style.smalltalk.16=$(colour.keyword),bold -------------------------------------------------------------------------------- /src/sorcins.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for SORCUS Installation Files 2 | # Originally by Christoph Baumann cb@sorcus.com 3 | 4 | # SORCUS Installation files end with .ins 5 | file.patterns.sorcins=*.ins 6 | filter.sorcins=SORCUS Installation File (ins)|$(file.patterns.sorcins)| 7 | 8 | *filter.sorcins=$(filter.sorcins) 9 | 10 | lexer.$(file.patterns.sorcins)=sorcins 11 | 12 | commands=ARGUSCONNECTCHANNELS \ 13 | M2DEVICE M2INST M2PAR M2PROC M2FUNC M2CMD M2LOADMODUL \ 14 | M6DEVICE M6INST M6PAR M6PROC M6FUNC M6CMD M6LOADMODUL \ 15 | M7DEVICE M7INST M7PAR M7PROC M7FUNC M7CMD M7LOADMODUL \ 16 | M8DEVICE M8INST M8PAR M8PROC M8FUNC M8CMD M8LOADMODUL \ 17 | MAXRESET MAXCONNECTCPU MAXLOADOSX MAXINST MAXPROC \ 18 | MAXFUNC MAXPAR MAXLOADMDD MAXFLASHFILE 19 | 20 | parameter=board slot layer osx file no usage task tasktype level irq flags \ 21 | datasize func para start progno name count index TIMEOUT RESET 22 | 23 | constants=MAX_NI_TASK MAX_TI_TASK MAX_II_TASK MAX_DI_TASK 24 | 25 | keywords.$(file.patterns.sorcins)=$(commands) 26 | keywords2.$(file.patterns.sorcins)=$(parameter) 27 | keywords3.$(file.patterns.sorcins)=$(constants) 28 | 29 | comment.block.sorcins=; 30 | 31 | # Default 32 | style.sorcins.0= 33 | # Command 34 | style.sorcins.1=fore:#0000ff 35 | # Parameter 36 | style.sorcins.2=fore:#808080 37 | # Comment line 38 | style.sorcins.3=fore:#008000 39 | # String 40 | style.sorcins.4=fore:#ff0000 41 | # End of line where string is not closed 42 | style.sorcins.5= 43 | # Identifier 44 | style.sorcins.6= 45 | # Operator 46 | style.sorcins.7= 47 | # Number 48 | style.sorcins.8= 49 | # Constant 50 | style.sorcins.9=fore:#ff00ff 51 | -------------------------------------------------------------------------------- /src/spice.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for spice files. 2 | 3 | file.patterns.spice=*.scp;*.out 4 | filter.spice=Spice (out scp)|$(file.patterns.spice)| 5 | *filter.spice=$(filter.spice) 6 | lexer.$(file.patterns.spice)=spice 7 | 8 | #indent.size.$(file.patterns.spice)=3 9 | #use.tabs.$(file.patterns.spice)=0 10 | 11 | # Keyword for script commands 12 | keywordclass.spice.command=\ 13 | ac alias alter alterparam append askvalues assertvalid autoscale \ 14 | break compose copy copytodoc dc delete destroy destroyvec diff display \ 15 | disto dowhile echo else end errorstop fftinit filter foreach fourier \ 16 | freqtotime function functionundef goto homecursors if isdisplayed label \ 17 | let linearize listing load loadaccumulator makelabel movelabel makesmithplot \ 18 | movecursorleft movecursorright msgbox nameplot newplot nextparam noise \ 19 | nopoints op plot plotf plotref poly print printcursors printevent printname \ 20 | printplot printstatus printtext printtol printunits printval printvector \ 21 | pwl pz quit removesmithplot rename repeat resume rotate runs rusage \ 22 | save sendplot sendscript sens set setcursor setdoc setlabel setlabeltype \ 23 | setmargins setnthtrigger setunits setvec setparam setplot setquery \ 24 | setscaletype settracecolor settracestyle setsource settrigger setvec \ 25 | setxlimits setylimits show showmod sort status step stop switch \ 26 | tf timetofreq timetowave tran unalias unlet unset unalterparam \ 27 | update version view wavefilter wavetotime where while write 28 | # Keywords for script functions 29 | keywordclass.spice.functions=\ 30 | abs askvalue atan average ceil cos db differentiate differentiatex \ 31 | exp finalvalue floor getcursorx getcursory getcursory0 getcursory1 \ 32 | getparam im ln initialvalue integrate integratex interpolate isdef \ 33 | isdisplayed j log length mag, max maxscale mean meanpts min minscale \ 34 | nextplot nextvector norm operatingpoint ph phase phaseextend pk_pk \ 35 | pos pulse re rms rmspts rnd sameplot sin sqrt stddev stddevpts tan \ 36 | tfall tolerance trise unitvec vector 37 | # Keywords for spice parameters 38 | keywordclass.spice.params=param nodeset include options dcconv subckt ends model 39 | 40 | 41 | keywordclass.spice=$(keywordclass.spice.command) $(keywordclass.spice.functions) $(keywordclass.spice.params) 42 | 43 | keywords.$(file.patterns.spice)=$(keywordclass.spice.command) 44 | keywords2.$(file.patterns.spice)=$(keywordclass.spice.functions) 45 | keywords3.$(file.patterns.spice)=$(keywordclass.spice.params) 46 | 47 | # spice styles 48 | # Default 49 | style.spice.0=fore:#808080 50 | # Identifiers 51 | style.spice.1= 52 | # Keyword 53 | style.spice.2=$(colour.keyword) 54 | # Keyword2 55 | style.spice.3=$(colour.keyword),bold 56 | # Keyword3 57 | style.spice.4=fore:#0040E0 58 | # Number 59 | style.spice.5=$(colour.number) 60 | # Operators (delimiters) 61 | style.spice.6=$(colour.operator),bold 62 | # Value 63 | style.spice.7=$(colour.char) 64 | # Comment 65 | style.spice.8=$(colour.code.comment.line),$(font.code.comment.line) 66 | 67 | # Comments 68 | comment.block.spice=*~ 69 | 70 | braces.spice.style=4 71 | 72 | statement.indent.$(file.patterns.spice)=5 begin declare else elsif exception for if is loop while 73 | statement.lookback.$(file.patterns.spice)=20 74 | block.start.$(file.patterns.spice)=10 then is 75 | block.end.$(file.patterns.spice)=10 end 76 | 77 | calltip.spice.word.characters=._$(chars.alpha) 78 | -------------------------------------------------------------------------------- /src/tacl.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for TACL files. 2 | 3 | file.patterns.TACL=*.tacl 4 | filter.tacl=TACL (TACL)|$(file.patterns.TACL)| 5 | *filter.tacl=$(filter.tacl) 6 | 7 | lexer.$(file.patterns.TACL)=TACL 8 | 9 | # These keywords are case insensitive 10 | keywords.$(file.patterns.TACL)=activate add adddsttransition adduser alter altpri assign attachseg backupcpu break builtins buscmd clear columnize comment compute copy dump copyvar create createseg debug debugnow default delete deluser detachseg env exit fileinfo filenames files filetovar help history home info initterm inlecho inleof inlout inlprefix inlto join keep keys lights load loaded files logoff logon o obey outvar param password pause pmsearch pmsg pop ppd purge push rcvdump receivedump reload remotepassword rename reset rpasswrd run rund seginfo set setprompt settime show sink status stop suspend switch system systimes time timestamp_to_text useusers variables varinfo vartofile vchange vcopy vdelete vfind vinsert vlist vmove volume vtree wakeup who xbusdown xbusup ybusdown ybusup _comparev _contime_to_text _contime_to_text_date _contime_to_text_time _debugger _execute _longest _month3 11 | 12 | comment.block.TACL=== 13 | 14 | # TACL styles 15 | # 1,Comment|2,Line Comment|3,Doc Comment|4,Number|5,Builtin|6,String|7,Character|8,Command|9,Preprocessor|10,Operator 16 | # 11,Identifier|16,Label| 17 | style.TACL.0=fore:#808080,$(font.monospace) 18 | 19 | # Comment 20 | style.TACL.1=$(colour.text.comment),$(font.code.comment) 21 | # Line comment 22 | style.TACL.2=$(colour.code.comment.line),$(font.code.comment.line) 23 | # Doc comment 24 | style.TACL.3=$(colour.code.comment.document),$(font.code.comment.document) 25 | # Number 26 | style.TACL.4=$(colour.number),$(font.monospace) 27 | # Builtin 28 | style.TACL.5=$(colour.keyword),bold,$(font.monospace) 29 | # String 30 | style.TACL.6=$(colour.string),$(font.monospace),$(font.monospace) 31 | # Character 32 | style.TACL.7=$(colour.char),$(font.monospace),$(font.monospace) 33 | # Command 34 | style.TACL.8=back:#C0C0C0,bold,$(font.monospace) 35 | # Preprocessor 36 | style.TACL.9=$(colour.preproc),$(font.preproc),$(font.monospace) 37 | # Operators 38 | style.TACL.10=$(colour.operator),bold,$(font.monospace) 39 | # Identifier 40 | style.TACL.11=$(colour.identifier),$(font.identifier),$(font.monospace) 41 | # Label 42 | style.TACL.16=fore:#0020F0,$(font.monospace) 43 | 44 | 45 | -------------------------------------------------------------------------------- /src/tal.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for TAL files. 2 | file.patterns.TAL=*.TAL 3 | filter.tal=TAL (TAL)|$(file.patterns.TAL)| 4 | *filter.tal=$(filter.tal) 5 | 6 | lexer.$(file.patterns.TAL)=TAL 7 | 8 | # These keywords are case insensitive 9 | keywords.$(file.patterns.TAL)=and assert baddr begin by call callable case cbaddr code cwaddr define do downto drop else end entry external fixed for forward goto if int interrupt label land literal lor main not of or otherwise priv proc procaddr real resident return rscan scan sgbaddr sgwaddr sgxbaddr sgxwaddr stack store string struct subproc then to unsigned until use variable waddr while xor 10 | keywords2.$(file.patterns.TAL)=at below bit_filler block bytes c cobol elements ext extensible filler fortran language name pascal private unspecified words 11 | 12 | comment.block.TAL=-- 13 | 14 | # TAL styles 15 | # 1,Comment|2,Line Comment|3,Doc Comment|4,Number|5,Keyword|6,String|7,Character|8,Unreserved keyword|9,Preprocessor|10,Operator 16 | # 11,Identifier 17 | style.TAL.0=fore:#808080 18 | 19 | # Comment 20 | style.TAL.1=fore:#008000,$(font.code.comment) 21 | # Line comment 22 | style.TAL.2=$(colour.code.comment.line),$(font.code.comment.line) 23 | # Doc comment 24 | style.TAL.3=$(colour.code.comment.document),$(font.code.comment.document) 25 | # Number 26 | style.TAL.4=$(colour.number) 27 | # Keyword 28 | style.TAL.5=$(colour.keyword),bold 29 | # String 30 | style.TAL.6=$(colour.string),$(font.monospace) 31 | # Character 32 | style.TAL.7=$(colour.char),$(font.monospace) 33 | # Unreserved keyword 34 | style.TAL.8=$(colour.keyword),bold 35 | # Preprocessor 36 | style.TAL.9=$(colour.preproc),$(font.preproc) 37 | # Operators 38 | style.TAL.10=$(colour.operator),bold 39 | # Identifier 40 | style.TAL.11=$(colour.identifier),$(font.identifier) 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /src/txt2tags.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for txt2tags. 2 | 3 | file.patterns.txt2tags=*.t2t 4 | 5 | shbang.txt2tags=txt2tags 6 | 7 | filter.txt2tags=Txt2tags (t2t)|$(file.patterns.txt2tags)| 8 | 9 | *filter.txt2tags=$(filter.txt2tags) 10 | 11 | lexer.$(file.patterns.txt2tags)=txt2tags 12 | 13 | *language.txt2tags=&txt2tags|t2t|| 14 | 15 | # Default 16 | style.txt2tags.0=fore:#000000 17 | 18 | # Special 19 | style.txt2tags.1=fore:#000000 20 | 21 | # STRONG 22 | style.txt2tags.2=fore:#445675,bold 23 | 24 | # STRONG 2 (not used) 25 | style.txt2tags.3=fore:#445675 26 | 27 | # EM1 (italic) 28 | style.txt2tags.4=fore:#653A39,italics 29 | 30 | # EM2 (underline) 31 | style.txt2tags.5=fore:#386742 32 | 33 | # H1 34 | style.txt2tags.6=fore:#E20700,bold 35 | 36 | # H2 37 | style.txt2tags.7=fore:#E20700,bold 38 | 39 | # H3 40 | style.txt2tags.8=fore:#A81D05,bold 41 | 42 | # H4 43 | style.txt2tags.9=fore:#871704,bold 44 | 45 | # H5 46 | style.txt2tags.10=fore:#871704,bold 47 | 48 | # H6 49 | style.txt2tags.11=fore:#871704,bold 50 | 51 | # prechar (not used) 52 | style.txt2tags.12=fore:#871704,bold 53 | 54 | # list 55 | style.txt2tags.13=fore:#E300EE 56 | 57 | # list 58 | style.txt2tags.14=fore:#E300EE 59 | 60 | # BLOCKQUOTE 61 | style.txt2tags.15=fore:#015F52 62 | 63 | # STRIKEOUT 64 | style.txt2tags.16=fore:#644A9B 65 | 66 | # HRULE 67 | style.txt2tags.17=fore:#ff901e 68 | 69 | # LINK 70 | style.txt2tags.18=fore:#0930DE,italics 71 | 72 | # CODE 73 | style.txt2tags.19=fore:#009f00 74 | 75 | # CODE2 76 | style.txt2tags.20=fore:#009f00 77 | 78 | # CODEBLOCK 79 | style.txt2tags.21=fore:#005f00 80 | 81 | # COMMENT 82 | style.txt2tags.22=fore:#777777 83 | 84 | # OPTION 85 | style.txt2tags.23=fore:#C0036E 86 | 87 | # PREPROC 88 | style.txt2tags.24=fore:#848B00 89 | 90 | # POSTPROC 91 | style.txt2tags.25=fore:#C05600 92 | 93 | 94 | 95 | -------------------------------------------------------------------------------- /src/yaml.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for YAML files. 2 | 3 | # associate YAML file patter with the YAML lexer 4 | file.patterns.yaml=*.yaml;*.yml;*.clang-format;*.clang-tidy;*.mir;*.apinotes;*.ifs 5 | filter.yaml=YAML (yaml)|$(file.patterns.yaml)| 6 | *filter.yaml=$(filter.yaml) 7 | lexer.$(file.patterns.yaml)=yaml 8 | *language.yaml=YAML|yaml|| 9 | 10 | # YAML requires spaces for tabs 11 | tabsize.$(file.patterns.yaml)=2 12 | indent.size.$(file.patterns.yaml)=2 13 | use.tabs.$(file.patterns.yaml)=0 14 | 15 | # YAML comment character 16 | comment.block.yaml=#~ 17 | 18 | # YAML convertible values 19 | keywords.$(file.patterns.yaml)=true false yes no 20 | 21 | #fold.comment.yaml=1 22 | 23 | # YAML font styles 24 | # default 25 | style.yaml.0=$(font.text),fore:#000000 26 | # comment line 27 | style.yaml.1=$(font.comment),fore:#008800 28 | # value identifier 29 | style.yaml.2=$(font.base),fore:#000088,bold 30 | # keyword value 31 | style.yaml.3=$(font.base),fore:#880088 32 | # numerical value 33 | style.yaml.4=$(font.base),fore:#880000 34 | # reference/repeating value 35 | style.yaml.5=$(font.base),fore:#008888 36 | # document delimiting line 37 | style.yaml.6=$(font.comment),fore:#FFFFFF,bold,back:#000088,eolfilled 38 | # text block marker 39 | style.yaml.7=$(font.text),fore:#333366 40 | # syntax error marker 41 | style.yaml.8=$(font.text),fore:#FFFFFF,italics,bold,back:#FF0000,eolfilled 42 | # operator 43 | style.yaml.9=$(colour.operator) 44 | -------------------------------------------------------------------------------- /test/UnitTester.cxx: -------------------------------------------------------------------------------- 1 | /** @file UnitTester.cxx 2 | ** UnitTester.cxx : Defines the entry point for the console application. 3 | **/ 4 | 5 | // Catch uses std::uncaught_exception which is deprecated in C++17. 6 | // This define silences a warning from Visual C++. 7 | #define _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING 8 | 9 | #include 10 | #include 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #if defined(_WIN32) 18 | #define CATCH_CONFIG_WINDOWS_CRTDBG 19 | #endif 20 | #define CATCH_CONFIG_RUNNER 21 | #include "catch.hpp" 22 | 23 | int main(int argc, char* argv[]) { 24 | const int result = Catch::Session().run(argc, argv); 25 | 26 | return result; 27 | } 28 | -------------------------------------------------------------------------------- /test/makefile: -------------------------------------------------------------------------------- 1 | # Build all the unit tests using GNU make and either g++ or clang 2 | # Should be run using mingw32-make on Windows, not nmake 3 | # On Windows g++ is used, on macOS clang, and on Linux G++ is used by default 4 | # but clang can be used by defining CLANG when invoking make 5 | # clang works only with libc++, not libstdc++ 6 | # Tested with clang 17 and g++ 11.2 7 | 8 | CXXSTD=c++20 9 | 10 | ifndef windir 11 | ifeq ($(shell uname),Darwin) 12 | # On macOS (detected with Darwin uname) always use clang as g++ is old version 13 | CLANG = 1 14 | USELIBCPP = 1 15 | endif 16 | endif 17 | 18 | CXXFLAGS += $(OPTIMIZATION) 19 | CXXFLAGS += --std=$(CXXSTD) 20 | 21 | ifdef CLANG 22 | CXX = clang++ 23 | ifdef USELIBCPP 24 | # macOS, use libc++ but don't have sanitizers 25 | CXXFLAGS += --stdlib=libc++ 26 | else 27 | ifndef windir 28 | # Linux, have sanitizers 29 | SANITIZE = -fsanitize=address,undefined 30 | CXXFLAGS += $(SANITIZE) 31 | endif 32 | endif 33 | else 34 | CXX = g++ 35 | endif 36 | 37 | ifdef windir 38 | DEL = del /q 39 | EXE = unitTest.exe 40 | else 41 | DEL = rm -f 42 | EXE = unitTest 43 | endif 44 | 45 | vpath %.cxx ../src 46 | 47 | INCLUDEDIRS = -I ../src 48 | 49 | CPPFLAGS += $(INCLUDEDIRS) 50 | CXXFLAGS += -Wall -Wextra 51 | 52 | # Files in this directory containing tests 53 | TESTSRC=$(wildcard test*.cxx) 54 | TESTOBJ=$(TESTSRC:.cxx=.o) 55 | 56 | # Files being tested from scintilla/src directory 57 | TESTEDOBJ=\ 58 | Cookie.o \ 59 | StringHelpers.o \ 60 | Utf8_16.o 61 | 62 | TESTS=$(EXE) 63 | 64 | all: $(TESTS) 65 | 66 | test: $(TESTS) 67 | ./$(EXE) 68 | 69 | clean: 70 | $(DEL) $(TESTS) *.o *.obj *.exe 71 | 72 | %.o: %.cxx 73 | $(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ 74 | 75 | $(EXE): $(TESTOBJ) $(TESTEDOBJ) unitTest.o 76 | $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LINKFLAGS) $^ -o $@ 77 | -------------------------------------------------------------------------------- /test/test.mak: -------------------------------------------------------------------------------- 1 | # Build all the unit tests with Microsoft Visual C++ using nmake 2 | # Tested with Visual C++ 2022 3 | 4 | DEL = del /q 5 | EXE = unitTest.exe 6 | 7 | INCLUDEDIRS = /I../src 8 | 9 | CXXFLAGS = /MP /EHsc /std:c++20 $(OPTIMIZATION) /nologo /D_HAS_AUTO_PTR_ETC=1 /wd 4805 $(INCLUDEDIRS) 10 | 11 | # Files in this directory containing tests 12 | TESTSRC=test*.cxx 13 | # Files being tested from scintilla/src directory 14 | TESTEDSRC=\ 15 | ../src/Cookie.cxx \ 16 | ../src/StringHelpers.cxx \ 17 | ../src/Utf8_16.cxx 18 | 19 | TESTS=$(EXE) 20 | 21 | all: $(TESTS) 22 | 23 | test: $(TESTS) 24 | $(EXE) 25 | 26 | clean: 27 | $(DEL) $(TESTS) *.o *.obj *.exe 28 | 29 | $(EXE): $(TESTSRC) $(TESTEDSRC) $(@B).obj 30 | $(CXX) $(CXXFLAGS) /Fe$@ $** 31 | -------------------------------------------------------------------------------- /test/unitTest.cxx: -------------------------------------------------------------------------------- 1 | /** @file unitTest.cxx 2 | ** Unit Tests for SciTE internal data structures 3 | **/ 4 | 5 | /* 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | #if defined(__GNUC__) 17 | // Want to avoid misleading indentation warnings in catch.hpp but the pragma 18 | // may not be available so protect by turning off pragma warnings 19 | #pragma GCC diagnostic ignored "-Wunknown-pragmas" 20 | #pragma GCC diagnostic ignored "-Wpragmas" 21 | #if !defined(__clang__) 22 | #pragma GCC diagnostic ignored "-Wmisleading-indentation" 23 | #endif 24 | #endif 25 | 26 | #define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file 27 | #include "catch.hpp" 28 | -------------------------------------------------------------------------------- /tgzgscite: -------------------------------------------------------------------------------- 1 | cd .. 2 | rm -f gscite.tgz 3 | mkdir gscite 4 | cp scite/*.txt gscite 5 | cp scite/bin/SciTE gscite 6 | cp scite/bin/*.so gscite 7 | strip gscite/SciTE 8 | cp scite/src/*.properties gscite 9 | rm -f gscite/Embedded.properties 10 | cp scite/doc/*.html gscite 11 | cp scite/doc/*.png gscite 12 | cp scite/gtk/*.png gscite 13 | cp scite/doc/*.jpg gscite 14 | cp scite/doc/*.1 gscite 15 | tar --create gscite/* | gzip -c >gscite.tgz 16 | rm -f gscite/* 17 | rmdir gscite 18 | -------------------------------------------------------------------------------- /tgzsrc: -------------------------------------------------------------------------------- 1 | cd .. 2 | rm -f scite.tgz 3 | rm -f scite/bin/*.properties 4 | tar --create --exclude=*.o --exclude=*.obj --exclude=*.dll --exclude=*.so --exclude=*.exe --exclude=*.a --exclude=SciTE \ 5 | lexilla/* scintilla/* scite/* \ 6 | | gzip -c >scite.tgz 7 | -------------------------------------------------------------------------------- /upxsc1.bat: -------------------------------------------------------------------------------- 1 | del/q ..\Sc1.exe 2 | upx --best --force -o ..\Sc1.exe bin\Sc1.exe 3 | -------------------------------------------------------------------------------- /version.txt: -------------------------------------------------------------------------------- 1 | 552 -------------------------------------------------------------------------------- /win32/AppDepGen.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # AppDepGen.py - produce a make dependencies file for SciTE 3 | # Copyright 2019 by Neil Hodgson 4 | # The License.txt file describes the conditions under which this software may be distributed. 5 | # Requires Python 3.6 or later 6 | 7 | import sys 8 | 9 | srcRoot = "../.." 10 | 11 | sys.path.append(srcRoot + "/scintilla") 12 | 13 | from scripts import Dependencies 14 | 15 | topComment = "# Created by AppDepGen.py. To recreate, run AppDepGen.py.\n" 16 | 17 | def Generate(): 18 | sciteSources = ["../src/*.cxx", "../lua/src/*.c", "../../lexilla/access/*.cxx", "../../scintilla/call/*.cxx"] 19 | sciteIncludes = ["../../lexilla/include", "../../lexilla/access", "../../scintilla/include", "../src", "../lua/src"] 20 | 21 | # Header magically injected into Lua builds on Win32 to make Unicode file names work 22 | luaSubsts = { "LUA_USER_H": "scite_lua_win.h"} 23 | 24 | # Create the dependencies file for g++ 25 | deps = Dependencies.FindDependencies(["../win32/*.cxx"] + sciteSources, ["../win32"] + sciteIncludes, ".o", "../win32/", luaSubsts) 26 | 27 | # Add Sc1 as the same as SciTEWin 28 | deps = Dependencies.InsertSynonym(deps, "SciTEWin.o", "Sc1.o") 29 | 30 | Dependencies.UpdateDependencies("../win32/deps.mak", deps, topComment) 31 | 32 | # Create the dependencies file for MSVC 33 | 34 | # Change extension from ".o" to ".obj" 35 | deps = [[Dependencies.PathStem(obj)+".obj", headers] for obj, headers in deps] 36 | 37 | Dependencies.UpdateDependencies("../win32/nmdeps.mak", deps, topComment) 38 | 39 | if __name__ == "__main__": 40 | Generate() -------------------------------------------------------------------------------- /win32/DLLFunction.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file DLLFunction.h 3 | ** Templates to load functions from DLLs. 4 | **/ 5 | // Copyright 2020 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef DLLFUNCTION_H 9 | #define DLLFUNCTION_H 10 | 11 | /// Find a function in a DLL and convert to a function pointer. 12 | /// This avoids undefined and conditionally defined behaviour. 13 | template 14 | T DLLFunction(HMODULE hModule, LPCSTR lpProcName) noexcept { 15 | if (!hModule) { 16 | return nullptr; 17 | } 18 | FARPROC function = ::GetProcAddress(hModule, lpProcName); 19 | static_assert(sizeof(T) == sizeof(function)); 20 | T fp; 21 | memcpy(&fp, &function, sizeof(T)); 22 | return fp; 23 | } 24 | 25 | /// Find a function in an already loaded DLL and convert to a function pointer. 26 | template 27 | T DLLFunction(LPCWSTR lpModuleName, LPCSTR lpProcName) noexcept { 28 | return DLLFunction(::GetModuleHandleW(lpModuleName), lpProcName); 29 | } 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /win32/DirectorExtension.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file DirectorExtension.h 3 | ** Extension for communicating with a director program. 4 | **/ 5 | // Copyright 1998-2001 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef DIRECTOREXTENSION_H 9 | #define DIRECTOREXTENSION_H 10 | 11 | class DirectorExtension : public Extension { 12 | private: 13 | ExtensionAPI *host {}; 14 | DirectorExtension() {} // Singleton 15 | // Deleted so DirectorExtension objects can not be copied. 16 | DirectorExtension(const DirectorExtension &) = delete; 17 | void operator=(const DirectorExtension &) = delete; 18 | 19 | public: 20 | static DirectorExtension &Instance(); 21 | 22 | // Implement the Extension interface 23 | bool Initialise(ExtensionAPI *host_) override; 24 | bool Finalise() noexcept override; 25 | bool Clear() override; 26 | bool Load(const char *filename) override; 27 | 28 | bool OnOpen(const char *path) override; 29 | bool OnSwitchFile(const char *path) override; 30 | bool OnSave(const char *path) override; 31 | bool OnChar(char ch) override; 32 | bool OnExecute(const char *cmd) override; 33 | bool OnSavePointReached() override; 34 | bool OnSavePointLeft() override; 35 | bool OnStyle(Scintilla::Position startPos, Scintilla::Position lengthDoc, int initStyle, StyleWriter *styler) override; 36 | bool OnDoubleClick() override; 37 | bool OnUpdateUI() override; 38 | bool OnMarginClick() override; 39 | bool OnMacro(const char *command, const char *params) override; 40 | 41 | bool SendProperty(const char *prop) override; 42 | bool OnClose(const char *path) override; 43 | bool NeedsOnClose() override; 44 | 45 | // Allow messages through to extension 46 | void HandleStringMessage(const char *message); 47 | }; 48 | 49 | #endif 50 | -------------------------------------------------------------------------------- /win32/DragDrop.cur: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/DragDrop.cur -------------------------------------------------------------------------------- /win32/SciBall.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/SciBall.ico -------------------------------------------------------------------------------- /win32/SciTE.exe.manifest: -------------------------------------------------------------------------------- 1 | 2 | 4 | 10 | SciTE 11 | 12 | 13 | true 14 | PerMonitorV2 15 | 16 | 17 | 18 | 19 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /win32/UniqueInstance.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file UniqueInstance.h 3 | ** Header of the class to ensure a unique instance of the editor. 4 | **/ 5 | // Copyright 1998-2003 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef UNIQUEINSTANCE_H 9 | #define UNIQUEINSTANCE_H 10 | 11 | class SciTEWin; 12 | 13 | /** 14 | */ 15 | class UniqueInstance { 16 | 17 | private: 18 | SciTEWin *stw; ///< Access to SciTEWin interface 19 | UINT identityMessage; ///< Registered message to identify SciTE instances 20 | HANDLE mutex; ///< Mutex to avoid concurrent running 21 | std::wstring mutexName; ///< Name of the above 22 | bool bAlreadyRunning; ///< true if another instance accepting files is found 23 | HWND hOtherWindow; ///< Handle of the window of the found other instance 24 | 25 | public: 26 | UniqueInstance(); 27 | 28 | // Deleted so UniqueInstance objects can not be copied. 29 | UniqueInstance(const UniqueInstance &) = delete; 30 | UniqueInstance(UniqueInstance &&) = delete; 31 | UniqueInstance &operator=(const UniqueInstance &) = delete; 32 | UniqueInstance &operator=(UniqueInstance &&) = delete; 33 | 34 | ~UniqueInstance(); 35 | 36 | void Init(SciTEWin *stw_) noexcept; ///< To set the access to the SciTEWin interface 37 | bool AcceptToOpenFiles(bool bAccept); ///< Set mutex and see if succeed 38 | void CallSearchOnAllWindows(); ///< Common code used by ToggleOpenFilesHere and FindOtherInstance 39 | void ToggleOpenFilesHere(); ///< Change the option to open files in this instance and ask other instance to give up this option 40 | LRESULT CopyData(const COPYDATASTRUCT *pcds); ///< Send command line to existing instance 41 | LRESULT CheckMessage(UINT message, WPARAM wParam, LPARAM lParam); ///< Test if a given message is the identity message 42 | void CheckOtherInstance(); ///< Create mutex name and try to set it 43 | bool FindOtherInstance(); ///< Find another instance answering to the identity message 44 | void WindowCopyData(std::string_view s); ///< Send data to hOtherWindow 45 | void SendCommands(const char *cmdLine); ///< Send the command line to the other instance 46 | static BOOL CALLBACK SearchOtherInstance(HWND hWnd, LPARAM lParam); ///< Callback in the window enumeration 47 | }; 48 | 49 | #endif 50 | -------------------------------------------------------------------------------- /win32/around.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/around.bmp -------------------------------------------------------------------------------- /win32/around20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/around20.bmp -------------------------------------------------------------------------------- /win32/around24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/around24.bmp -------------------------------------------------------------------------------- /win32/around32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/around32.bmp -------------------------------------------------------------------------------- /win32/backslash.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/backslash.bmp -------------------------------------------------------------------------------- /win32/backslash20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/backslash20.bmp -------------------------------------------------------------------------------- /win32/backslash24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/backslash24.bmp -------------------------------------------------------------------------------- /win32/backslash32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/backslash32.bmp -------------------------------------------------------------------------------- /win32/case.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/case.bmp -------------------------------------------------------------------------------- /win32/case20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/case20.bmp -------------------------------------------------------------------------------- /win32/case24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/case24.bmp -------------------------------------------------------------------------------- /win32/case32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/case32.bmp -------------------------------------------------------------------------------- /win32/closefile.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/closefile.bmp -------------------------------------------------------------------------------- /win32/closefile24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/closefile24.bmp -------------------------------------------------------------------------------- /win32/context.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/context.bmp -------------------------------------------------------------------------------- /win32/context20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/context20.bmp -------------------------------------------------------------------------------- /win32/context24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/context24.bmp -------------------------------------------------------------------------------- /win32/context32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/context32.bmp -------------------------------------------------------------------------------- /win32/filter.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/filter.bmp -------------------------------------------------------------------------------- /win32/filter20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/filter20.bmp -------------------------------------------------------------------------------- /win32/filter24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/filter24.bmp -------------------------------------------------------------------------------- /win32/filter32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/filter32.bmp -------------------------------------------------------------------------------- /win32/regex.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/regex.bmp -------------------------------------------------------------------------------- /win32/regex20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/regex20.bmp -------------------------------------------------------------------------------- /win32/regex24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/regex24.bmp -------------------------------------------------------------------------------- /win32/regex32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/regex32.bmp -------------------------------------------------------------------------------- /win32/up.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/up.bmp -------------------------------------------------------------------------------- /win32/up20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/up20.bmp -------------------------------------------------------------------------------- /win32/up24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/up24.bmp -------------------------------------------------------------------------------- /win32/up32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/up32.bmp -------------------------------------------------------------------------------- /win32/word.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/word.bmp -------------------------------------------------------------------------------- /win32/word20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/word20.bmp -------------------------------------------------------------------------------- /win32/word24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/word24.bmp -------------------------------------------------------------------------------- /win32/word32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mirror/scite/d166c05a44a7177c2771805267345d37adc1211f/win32/word32.bmp -------------------------------------------------------------------------------- /zipsrc.bat: -------------------------------------------------------------------------------- 1 | cd .. 2 | del/q scite.zip 3 | zip scite.zip lexilla\*.* lexilla\*\*.* lexilla\*\*\*.* lexilla\*\*\*\*.* lexilla\*\*\*\*\*.* scintilla\*.* scintilla\*\*.* scintilla\*\*\*.* scintilla\*\*\*\*.* scintilla\*\*\*\*\*.* scite\*.* scite\*\*.* scite\*\*\*.* scite\*\*\*\*.* ^ 4 | -x *.o *.obj *.a *.lib *.dll *.exe *.pdb *.i *.res *.exp *.ncb *.sbr *.bsc *.tlog *.ilk *.ipch *.idb *.sdf *.dpsession *.bak *.tgz ^ 5 | **/__pycache__/* **/Debug/* **/Release/* **/x64/* **/ARM64/* **/cov-int/* */.hg/* @ 6 | cd scite 7 | -------------------------------------------------------------------------------- /zipwscite.bat: -------------------------------------------------------------------------------- 1 | cd .. 2 | del/q wscite.zip 3 | mkdir wscite 4 | copy scite\license.txt wscite 5 | copy scite\bin\SciTE*.exe wscite 6 | copy scite\bin\Lexilla.dll wscite 7 | copy scite\bin\Scintilla.dll wscite 8 | copy scite\src\*.properties wscite 9 | copy scite\lua\COPYRIGHT wscite\luaCOPYRIGHT 10 | del/q wscite\Embedded.properties 11 | copy scite\doc\*.html wscite 12 | copy scite\doc\*.png wscite 13 | copy scite\doc\*.jpg wscite 14 | copy scite\doc\*.1 wscite 15 | zip wscite.zip wscite\*.* 16 | del/q wscite\*.* 17 | rmdir wscite 18 | cd scite 19 | -------------------------------------------------------------------------------- /zipwscited.bat: -------------------------------------------------------------------------------- 1 | cd .. 2 | del/q wscite.zip 3 | mkdir wscite 4 | copy scite\license.txt wscite 5 | copy scite\bin\SciTE*.exe wscite 6 | copy scite\bin\SciTE.pdb wscite 7 | copy scite\bin\SciLexer.dll wscite 8 | copy scite\bin\SciLexer.pdb wscite 9 | copy scite\src\*.properties wscite 10 | copy scite\lua\COPYRIGHT wscite\luaCOPYRIGHT 11 | del/q wscite\Embedded.properties 12 | copy scite\doc\*.html wscite 13 | copy scite\doc\*.png wscite 14 | copy scite\doc\*.jpg wscite 15 | copy scite\doc\*.1 wscite 16 | zip wscite.zip wscite\*.* 17 | del/q wscite\*.* 18 | rmdir wscite 19 | cd scite 20 | --------------------------------------------------------------------------------