├── README.md └── src ├── License-SciTE-with-Python ├── archive ├── .gitignore ├── prev │ ├── bin │ │ ├── scite_366_win32.zip │ │ ├── scite_pyextend_05_225_win32.zip │ │ └── scite_pyextend_06_225_win32.zip │ └── src │ │ ├── scintilla_main_225.zip │ │ ├── scite_main_225.zip │ │ ├── scite_pyextend_05_225.zip │ │ └── scite_pyextend_07b_225.zip └── tools │ ├── prev │ ├── clipcircle │ │ ├── clipcircle32.sln │ │ ├── clipcircle32 │ │ │ ├── clipcircle.h │ │ │ ├── clipcircle32.vcproj │ │ │ ├── common.h │ │ │ ├── icon.ico │ │ │ ├── main.cpp │ │ │ ├── sendinput.cpp │ │ │ └── sendinput.h │ │ └── readme.txt │ ├── gedit_regex_replace │ │ ├── readme.txt │ │ ├── regex_replace.gedit-plugin │ │ └── regex_replace │ │ │ ├── __init__.py │ │ │ ├── regexsearch.glade │ │ │ ├── regexsearch.gladep │ │ │ └── regexsearchinstance.py │ ├── python_printval │ │ └── printval.py │ ├── simple_source_index │ │ ├── LICENSE │ │ ├── readme.txt │ │ ├── sqlite3.dll.zip │ │ ├── ssip.sln │ │ ├── ssip │ │ │ ├── dbaccess.c │ │ │ ├── dbaccess.h │ │ │ ├── hash.c │ │ │ ├── hash.h │ │ │ ├── main.c │ │ │ ├── sip.c │ │ │ ├── sip.h │ │ │ ├── sqlite3.h │ │ │ ├── sqlite3.lib │ │ │ ├── ssip.vcxproj │ │ │ ├── ssip.vcxproj.filters │ │ │ ├── text.c │ │ │ ├── text.h │ │ │ ├── util.c │ │ │ ├── util.h │ │ │ ├── util_win32.c │ │ │ └── util_win32.h │ │ ├── ssipexample.cfg │ │ └── test │ │ │ ├── definedtest.py │ │ │ ├── definedtestext.py │ │ │ ├── perftest.py │ │ │ └── testdata │ │ │ ├── folder1 │ │ │ ├── contrived.cpp │ │ │ ├── effects.cpp │ │ │ ├── notsour.ce │ │ │ ├── notsource.c.not │ │ │ └── src1.c │ │ │ └── folder2 │ │ │ └── src2.h │ └── wrappers │ │ ├── bit_tools.py │ │ └── mysha1.py │ └── wincommondialog │ └── WinCommonDialog │ ├── LICENSE │ ├── SciTE.properties │ ├── WinCommonDialog.cpp │ ├── WinCommonDialog.mak │ ├── dialog_color.cpp │ ├── dialog_file.cpp │ ├── dialog_simple.cpp │ ├── dialog_sound.cpp │ ├── dialog_textinput.cpp │ ├── readme.txt │ ├── resource.h │ ├── utils.cpp │ ├── utils.h │ └── wcdresources.rc ├── dloadlin.md ├── dloadwin.md ├── dloadwin_src.md └── scite ├── .gitignore ├── Documentation.txt ├── License-SciTE ├── License-Scintilla ├── building.txt ├── changes.txt ├── empty.md ├── scintilla ├── bin │ └── empty.txt ├── doc │ ├── Design.html │ ├── Icons.html │ ├── Indicators.png │ ├── Lexer.txt │ ├── Markers.png │ ├── Privacy.html │ ├── SciBreak.jpg │ ├── SciCoding.html │ ├── SciRest.jpg │ ├── SciTEIco.png │ ├── SciWord.jpg │ ├── ScintillaDoc.html │ ├── ScintillaDownload.html │ ├── ScintillaHistory.html │ ├── ScintillaRelated.html │ ├── ScintillaToDo.html │ ├── ScintillaUsage.html │ ├── Steps.html │ ├── annotations.png │ ├── index.html │ └── styledmargin.png ├── gtk │ ├── Converter.h │ ├── PlatGTK.cxx │ ├── ScintillaGTK.cxx │ ├── deps.mak │ ├── makefile │ ├── scintilla-marshal.c │ ├── scintilla-marshal.h │ └── scintilla-marshal.list ├── include │ ├── ILexer.h │ ├── Platform.h │ ├── SciLexer.h │ ├── Sci_Position.h │ ├── Scintilla.h │ ├── Scintilla.iface │ └── ScintillaWidget.h ├── lexers │ ├── LexA68k.cxx │ ├── LexAPDL.cxx │ ├── LexASY.cxx │ ├── LexAU3.cxx │ ├── LexAVE.cxx │ ├── LexAVS.cxx │ ├── LexAbaqus.cxx │ ├── LexAda.cxx │ ├── LexAsm.cxx │ ├── LexAsn1.cxx │ ├── LexBaan.cxx │ ├── LexBash.cxx │ ├── LexBasic.cxx │ ├── LexBatch.cxx │ ├── LexBibTeX.cxx │ ├── LexBullant.cxx │ ├── LexCLW.cxx │ ├── LexCOBOL.cxx │ ├── LexCPP.cxx │ ├── LexCSS.cxx │ ├── LexCaml.cxx │ ├── LexCmake.cxx │ ├── LexCoffeeScript.cxx │ ├── LexConf.cxx │ ├── LexCrontab.cxx │ ├── LexCsound.cxx │ ├── LexD.cxx │ ├── LexDMAP.cxx │ ├── LexDMIS.cxx │ ├── LexDiff.cxx │ ├── LexECL.cxx │ ├── LexEScript.cxx │ ├── LexEiffel.cxx │ ├── LexErlang.cxx │ ├── LexErrorList.cxx │ ├── LexFlagship.cxx │ ├── LexForth.cxx │ ├── LexFortran.cxx │ ├── LexGAP.cxx │ ├── LexGui4Cli.cxx │ ├── LexHTML.cxx │ ├── LexHaskell.cxx │ ├── LexHex.cxx │ ├── LexInno.cxx │ ├── LexJSON.cxx │ ├── LexKVIrc.cxx │ ├── LexKix.cxx │ ├── LexLaTeX.cxx │ ├── LexLisp.cxx │ ├── LexLout.cxx │ ├── LexLua.cxx │ ├── LexMMIXAL.cxx │ ├── LexMPT.cxx │ ├── LexMSSQL.cxx │ ├── LexMagik.cxx │ ├── LexMake.cxx │ ├── LexMarkdown.cxx │ ├── LexMatlab.cxx │ ├── LexMetapost.cxx │ ├── LexModula.cxx │ ├── LexMySQL.cxx │ ├── LexNimrod.cxx │ ├── LexNsis.cxx │ ├── LexNull.cxx │ ├── LexOScript.cxx │ ├── LexOpal.cxx │ ├── LexPB.cxx │ ├── LexPLM.cxx │ ├── LexPO.cxx │ ├── LexPOV.cxx │ ├── LexPS.cxx │ ├── LexPascal.cxx │ ├── LexPerl.cxx │ ├── LexPowerPro.cxx │ ├── LexPowerShell.cxx │ ├── LexProgress.cxx │ ├── LexProps.cxx │ ├── LexPython.cxx │ ├── LexR.cxx │ ├── LexRebol.cxx │ ├── LexRegistry.cxx │ ├── LexRuby.cxx │ ├── LexRust.cxx │ ├── LexSML.cxx │ ├── LexSQL.cxx │ ├── LexSTTXT.cxx │ ├── LexScriptol.cxx │ ├── LexSmalltalk.cxx │ ├── LexSorcus.cxx │ ├── LexSpecman.cxx │ ├── LexSpice.cxx │ ├── LexTACL.cxx │ ├── LexTADS3.cxx │ ├── LexTAL.cxx │ ├── LexTCL.cxx │ ├── LexTCMD.cxx │ ├── LexTeX.cxx │ ├── LexTxt2tags.cxx │ ├── LexVB.cxx │ ├── LexVHDL.cxx │ ├── LexVerilog.cxx │ ├── LexVisualProlog.cxx │ └── LexYAML.cxx ├── lexlib │ ├── Accessor.cxx │ ├── Accessor.h │ ├── CharacterCategory.cxx │ ├── CharacterCategory.h │ ├── CharacterSet.cxx │ ├── CharacterSet.h │ ├── LexAccessor.h │ ├── LexerBase.cxx │ ├── LexerBase.h │ ├── LexerModule.cxx │ ├── LexerModule.h │ ├── LexerNoExceptions.cxx │ ├── LexerNoExceptions.h │ ├── LexerSimple.cxx │ ├── LexerSimple.h │ ├── OptionSet.h │ ├── PropSetSimple.cxx │ ├── PropSetSimple.h │ ├── SparseState.h │ ├── StringCopy.h │ ├── StyleContext.cxx │ ├── StyleContext.h │ ├── SubStyles.h │ ├── WordList.cxx │ └── WordList.h ├── scripts │ ├── Face.py │ ├── FileGenerator.py │ ├── GenerateCaseConvert.py │ ├── GenerateCharacterCategory.py │ ├── HFacer.py │ ├── HeaderOrder.txt │ ├── LexGen.py │ └── ScintillaData.py ├── src │ ├── AutoComplete.cxx │ ├── AutoComplete.h │ ├── CallTip.cxx │ ├── CallTip.h │ ├── CaseConvert.cxx │ ├── CaseConvert.h │ ├── CaseFolder.cxx │ ├── CaseFolder.h │ ├── Catalogue.cxx │ ├── Catalogue.h │ ├── CellBuffer.cxx │ ├── CellBuffer.h │ ├── CharClassify.cxx │ ├── CharClassify.h │ ├── ContractionState.cxx │ ├── ContractionState.h │ ├── Decoration.cxx │ ├── Decoration.h │ ├── Document.cxx │ ├── Document.h │ ├── EditModel.cxx │ ├── EditModel.h │ ├── EditView.cxx │ ├── EditView.h │ ├── Editor.cxx │ ├── Editor.h │ ├── ExternalLexer.cxx │ ├── ExternalLexer.h │ ├── FontQuality.h │ ├── Indicator.cxx │ ├── Indicator.h │ ├── KeyMap.cxx │ ├── KeyMap.h │ ├── LineMarker.cxx │ ├── LineMarker.h │ ├── MarginView.cxx │ ├── MarginView.h │ ├── Partitioning.h │ ├── PerLine.cxx │ ├── PerLine.h │ ├── Position.h │ ├── PositionCache.cxx │ ├── PositionCache.h │ ├── RESearch.cxx │ ├── RESearch.h │ ├── RunStyles.cxx │ ├── RunStyles.h │ ├── SciTE.properties │ ├── ScintillaBase.cxx │ ├── ScintillaBase.h │ ├── Selection.cxx │ ├── Selection.h │ ├── SplitVector.h │ ├── Style.cxx │ ├── Style.h │ ├── UniConversion.cxx │ ├── UniConversion.h │ ├── UnicodeFromUTF8.h │ ├── ViewStyle.cxx │ ├── ViewStyle.h │ ├── XPM.cxx │ └── XPM.h ├── version.txt └── win32 │ ├── CheckD2D.cxx │ ├── HanjaDic.cxx │ ├── HanjaDic.h │ ├── PlatWin.cxx │ ├── PlatWin.h │ ├── SciLexer.vcxproj │ ├── SciTE.properties │ ├── ScintRes.rc │ ├── Scintilla.def │ ├── ScintillaWin.cxx │ ├── deps.mak │ ├── makefile │ └── scintilla.mak └── scite ├── bin ├── License-SciTE-with-Python ├── doc │ ├── BindingsGTK.html │ ├── BindingsWin32.html │ ├── Documentation.txt │ └── SciTEWithPythonAPIReference.html ├── properties │ ├── SciTEGlobal.properties │ ├── asm.properties │ ├── cpp.properties │ ├── disabled │ │ ├── abaqus.properties │ │ ├── asl.properties │ │ ├── asn1.properties │ │ ├── au3.properties │ │ ├── ave.properties │ │ ├── avs.properties │ │ ├── baan.properties │ │ ├── blitzbasic.properties │ │ ├── bullant.properties │ │ ├── cmake.properties │ │ ├── cobol.properties │ │ ├── coffeescript.properties │ │ ├── csound.properties │ │ ├── ecl.properties │ │ ├── eiffel.properties │ │ ├── erlang.properties │ │ ├── escript.properties │ │ ├── flagship.properties │ │ ├── forth.properties │ │ ├── freebasic.properties │ │ ├── gap.properties │ │ ├── haskell.properties │ │ ├── hex.properties │ │ ├── inno.properties │ │ ├── json.properties │ │ ├── kix.properties │ │ ├── latex.properties │ │ ├── lot.properties │ │ ├── lout.properties │ │ ├── metapost.properties │ │ ├── mmixal.properties │ │ ├── modula3.properties │ │ ├── nimrod.properties │ │ ├── nncrontab.properties │ │ ├── nsis.properties │ │ ├── opal.properties │ │ ├── oscript.properties │ │ ├── pov.properties │ │ ├── powerpro.properties │ │ ├── powershell.properties │ │ ├── ps.properties │ │ ├── purebasic.properties │ │ ├── r.properties │ │ ├── rebol.properties │ │ ├── scriptol.properties │ │ ├── smalltalk.properties │ │ ├── sorcins.properties │ │ ├── specman.properties │ │ ├── spice.properties │ │ ├── tacl.properties │ │ ├── tal.properties │ │ ├── txt2tags.properties │ │ ├── verilog.properties │ │ └── vhdl.properties │ ├── html.properties │ ├── lisp.properties │ ├── lua.properties │ ├── others.properties │ ├── perl.properties │ ├── python.properties │ ├── ruby.properties │ ├── rust.properties │ └── tex.properties ├── python27.zip ├── pythonbinaries.zip ├── scite_extend.py ├── scite_extend_tests.py ├── scite_extend_ui.py ├── setup.cfg ├── tools_external │ ├── send_scite │ │ └── __init__.py │ ├── tools_change_encoding │ │ ├── change_encoding.py │ │ └── register.properties │ ├── tools_example_ext │ │ └── register.properties │ ├── tools_py_error_context │ │ ├── __init__.py │ │ ├── py_error_context.py │ │ └── register.properties │ └── tools_search │ │ ├── __init__.py │ │ ├── code_search_definition.py │ │ ├── code_search_definition_filters.py │ │ ├── register.properties │ │ └── search_filenames.py └── tools_internal │ ├── ben_python_common │ ├── LICENSE │ ├── __init__.py │ ├── common_higher.py │ ├── common_jslike.py │ ├── common_ui.py │ ├── common_util.py │ ├── files.py │ ├── printclipboard.py │ ├── pyperclip │ │ ├── PKG-INFO │ │ ├── __init__.py │ │ ├── clipboards.py │ │ ├── exceptions.py │ │ └── windows.py │ ├── setup.cfg │ ├── store.py │ └── winprocess.py │ ├── tools_auto_type_xml │ ├── __init__.py │ └── register.properties │ ├── tools_current_directory │ ├── __init__.py │ └── register.properties │ ├── tools_disable_directory │ ├── __init__.py │ └── register.properties │ ├── tools_example_int │ ├── ExampleSubmodule.py │ ├── __init__.py │ └── register.properties │ ├── tools_insert_accented_character │ ├── __init__.py │ └── register.properties │ ├── tools_insert_text │ ├── __init__.py │ └── register.properties │ ├── tools_line_copy_if_no_selection │ ├── __init__.py │ └── register.properties │ ├── tools_location │ ├── __init__.py │ ├── goblocklocation.py │ ├── openselectedtext.py │ ├── register.properties │ └── reopenclosedfile.py │ ├── tools_quick_info │ ├── __init__.py │ └── register.properties │ ├── tools_regex_preview │ ├── __init__.py │ └── register.properties │ ├── tools_spelling_in_web_browser │ ├── __init__.py │ ├── register.properties │ └── template.html │ ├── tools_switch_instance │ ├── __init__.py │ └── register.properties │ ├── tools_switch_to_header │ ├── __init__.py │ ├── register.properties │ ├── switch_to_corresponding_dir.py │ └── switch_to_header.py │ ├── tools_text_information │ ├── __init__.py │ ├── register.properties │ ├── show_coding_reference.py │ └── show_selection_info.py │ ├── tools_text_transformations │ ├── __init__.py │ ├── changecasing.py │ ├── changelines.py │ ├── changeordernaturalsort.py │ ├── insertsequentialnumbers.py │ ├── movelines.py │ └── register.properties │ └── wincommondialog │ ├── __init__.py │ ├── tests.py │ └── wincommondialog.zip ├── gtk ├── DirectorExtension.cxx ├── DirectorExtension.h ├── GTKMutex.cxx ├── GUIGTK.cxx ├── Sci48Mpy.png ├── SciIcon.h ├── SciTEGTK.cxx ├── SciTE_with_python.desktop ├── Widget.cxx ├── Widget.h ├── deps.mak ├── lua.vers ├── makefile └── pixmapsGNOME.h ├── lua ├── COPYRIGHT ├── HISTORY ├── README ├── include │ ├── lauxlib.h │ ├── lua.h │ ├── luaconf.h │ └── lualib.h └── src │ ├── lapi.c │ ├── lapi.h │ ├── lcode.c │ ├── lcode.h │ ├── ldebug.c │ ├── ldebug.h │ ├── ldo.c │ ├── ldo.h │ ├── ldump.c │ ├── lfunc.c │ ├── lfunc.h │ ├── lgc.c │ ├── lgc.h │ ├── lib │ ├── lauxlib.c │ ├── lbaselib.c │ ├── ldblib.c │ ├── linit.c │ ├── liolib.c │ ├── lmathlib.c │ ├── loadlib.c │ ├── loslib.c │ ├── lstrlib.c │ └── ltablib.c │ ├── llex.c │ ├── llex.h │ ├── llimits.h │ ├── lmem.c │ ├── lmem.h │ ├── lobject.c │ ├── lobject.h │ ├── lopcodes.c │ ├── lopcodes.h │ ├── lparser.c │ ├── lparser.h │ ├── lstate.c │ ├── lstate.h │ ├── lstring.c │ ├── lstring.h │ ├── ltable.c │ ├── ltable.h │ ├── ltm.c │ ├── ltm.h │ ├── lundump.c │ ├── lundump.h │ ├── lvm.c │ ├── lvm.h │ ├── lzio.c │ └── lzio.h ├── python ├── include │ ├── Python-ast.h │ ├── Python.h │ ├── abstract.h │ ├── asdl.h │ ├── ast.h │ ├── bitset.h │ ├── boolobject.h │ ├── bufferobject.h │ ├── bytearrayobject.h │ ├── bytes_methods.h │ ├── bytesobject.h │ ├── cStringIO.h │ ├── cellobject.h │ ├── ceval.h │ ├── classobject.h │ ├── cobject.h │ ├── code.h │ ├── codecs.h │ ├── compile.h │ ├── complexobject.h │ ├── datetime.h │ ├── descrobject.h │ ├── dictobject.h │ ├── dtoa.h │ ├── enumobject.h │ ├── errcode.h │ ├── eval.h │ ├── fileobject.h │ ├── floatobject.h │ ├── frameobject.h │ ├── funcobject.h │ ├── genobject.h │ ├── graminit.h │ ├── grammar.h │ ├── import.h │ ├── intobject.h │ ├── intrcheck.h │ ├── iterobject.h │ ├── listobject.h │ ├── longintrepr.h │ ├── longobject.h │ ├── marshal.h │ ├── memoryobject.h │ ├── metagrammar.h │ ├── methodobject.h │ ├── modsupport.h │ ├── moduleobject.h │ ├── node.h │ ├── object.h │ ├── objimpl.h │ ├── opcode.h │ ├── osdefs.h │ ├── parsetok.h │ ├── patchlevel.h │ ├── pgen.h │ ├── pgenheaders.h │ ├── py_curses.h │ ├── pyarena.h │ ├── pycapsule.h │ ├── pyconfig.h │ ├── pyctype.h │ ├── pydebug.h │ ├── pyerrors.h │ ├── pyexpat.h │ ├── pyfpe.h │ ├── pygetopt.h │ ├── pymacconfig.h │ ├── pymactoolbox.h │ ├── pymath.h │ ├── pymem.h │ ├── pyport.h │ ├── pystate.h │ ├── pystrcmp.h │ ├── pystrtod.h │ ├── pythonrun.h │ ├── pythread.h │ ├── rangeobject.h │ ├── setobject.h │ ├── sliceobject.h │ ├── stringobject.h │ ├── structmember.h │ ├── structseq.h │ ├── symtable.h │ ├── sysmodule.h │ ├── timefuncs.h │ ├── token.h │ ├── traceback.h │ ├── tupleobject.h │ ├── ucnhash.h │ ├── unicodeobject.h │ ├── warnings.h │ └── weakrefobject.h └── libs.zip ├── scripts ├── CheckMentioned.py ├── CheckPropsDoc.py ├── IFaceTableGen.py ├── PythonExtensionGenReference.py ├── PythonExtensionGenTable.py ├── RegenerateSource.py ├── ShowBindings.py ├── ShowBindingsForSciTEPython.py ├── ba ├── checkbuildlinux.sh ├── checkbuilds.bat ├── clearboth.bat ├── commandsdoc.py ├── makerpms.py ├── scite.spec └── tags2api.py ├── src ├── Cookie.cxx ├── Cookie.h ├── Credits.cxx ├── 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 ├── Mutex.h ├── PropSetFile.cxx ├── PropSetFile.h ├── PythonExtension.cxx ├── PythonExtension.h ├── SciTE.h ├── SciTEBase.cxx ├── SciTEBase.h ├── SciTEBuffers.cxx ├── SciTEIO.cxx ├── SciTEKeys.h ├── SciTEProps.cxx ├── 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 └── scite_lua_win.h └── win32 ├── 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 ├── WinMutex.cxx ├── 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 ├── deps.mak ├── locale.properties ├── makefile ├── 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 /README.md: -------------------------------------------------------------------------------- 1 | # SciTE-with-Python 2 | 3 | * A fork of the SciTE code editor that adds Python scriptability 4 | 5 | * Download for [Linux](./src/dloadlin.md) or [Windows](./src/dloadwin.md) 6 | 7 | * Comes with 28 built-in plugins - and you can write your own in Python to insert and delete text, restyle ranges of text to underline or highlight, modify files/do anything else via the Python standard library, and automate nearly every editor action 8 | 9 | * [Full documentation - read more here!](https://moltenform.com/page/scite-with-python/doc/) 10 | 11 | ![Screenshot](https://moltenform.com/page/scite-with-python/doc/img/out-shot.png) 12 | 13 | -------------------------------------------------------------------------------- /src/archive/prev/bin/scite_366_win32.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/bin/scite_366_win32.zip -------------------------------------------------------------------------------- /src/archive/prev/bin/scite_pyextend_05_225_win32.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/bin/scite_pyextend_05_225_win32.zip -------------------------------------------------------------------------------- /src/archive/prev/bin/scite_pyextend_06_225_win32.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/bin/scite_pyextend_06_225_win32.zip -------------------------------------------------------------------------------- /src/archive/prev/src/scintilla_main_225.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/src/scintilla_main_225.zip -------------------------------------------------------------------------------- /src/archive/prev/src/scite_main_225.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/src/scite_main_225.zip -------------------------------------------------------------------------------- /src/archive/prev/src/scite_pyextend_05_225.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/src/scite_pyextend_05_225.zip -------------------------------------------------------------------------------- /src/archive/prev/src/scite_pyextend_07b_225.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/prev/src/scite_pyextend_07b_225.zip -------------------------------------------------------------------------------- /src/archive/tools/prev/clipcircle/clipcircle32.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 9.00 3 | # Visual Studio 2005 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "clipcircle32", "clipcircle32\clipcircle32.vcproj", "{36636394-DE0B-4D25-B5C1-88B0A58175A9}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {36636394-DE0B-4D25-B5C1-88B0A58175A9}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {36636394-DE0B-4D25-B5C1-88B0A58175A9}.Debug|Win32.Build.0 = Debug|Win32 14 | {36636394-DE0B-4D25-B5C1-88B0A58175A9}.Release|Win32.ActiveCfg = Release|Win32 15 | {36636394-DE0B-4D25-B5C1-88B0A58175A9}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /src/archive/tools/prev/clipcircle/clipcircle32/clipcircle.h: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | 4 | const int g_nItems = 8; 5 | 6 | // This class maintains a ring buffer of clipboard items. 7 | class ClipCircle 8 | { 9 | public: 10 | ClipCircle() 11 | { 12 | // initialize all strings to " " (a single space) 13 | for (int i=0; i<_countof(m_items); i++) 14 | m_items[i] = _wcsdup(L" "); 15 | 16 | m_ptr = 0; 17 | } 18 | ~ClipCircle() 19 | { 20 | for (int i=0; i<_countof(m_items);i++) 21 | free(m_items[i]); 22 | } 23 | 24 | // Push onto the buffer. 25 | void OnClipChange(const WCHAR* wz) 26 | { 27 | if (!wz || !wz[0]) 28 | return; 29 | 30 | // ignore if it is equal to the current one. 31 | if (wcscmp(wz, m_items[m_ptr])==0) 32 | return; 33 | 34 | // push it onto the ring 35 | m_ptr++; 36 | if (m_ptr >= g_nItems) m_ptr=0; 37 | free(m_items[m_ptr]); 38 | m_items[m_ptr] = _wcsdup(wz); 39 | } 40 | 41 | // Pop from the buffer. Output the string to the current window. 42 | void PasteAndCycle() 43 | { 44 | SetClipboardString(m_items[m_ptr]); 45 | SendKeyboardInputToWindow(m_items[m_ptr]); 46 | m_ptr--; 47 | if (m_ptr < 0) m_ptr = g_nItems-1; 48 | } 49 | 50 | private: 51 | WCHAR* m_items[g_nItems]; 52 | int m_ptr; 53 | }; 54 | 55 | -------------------------------------------------------------------------------- /src/archive/tools/prev/clipcircle/clipcircle32/common.h: -------------------------------------------------------------------------------- 1 | 2 | #pragma once 3 | 4 | // Keep compatibilty with WinXP. 5 | #define _WIN32_WINNT 0x05010000 6 | #define _WIN32_IE 0x0500 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #ifdef NTDDI_WINXP 13 | C_ASSERT(_WIN32_WINNT == NTDDI_WINXP); 14 | #endif 15 | #ifdef _WIN32_IE_IE50 16 | C_ASSERT(_WIN32_IE == _WIN32_IE_IE50); 17 | #endif 18 | 19 | inline void DisplayWarning(const char* sz) 20 | { 21 | MessageBoxA(0, sz, "clipcircle32", 0); 22 | } 23 | 24 | #ifdef DEBUG 25 | #define Assert(b) do { if (!(b)) DisplayWarning("assertion failed"); } while(0) 26 | #else 27 | #define Assert(b) 28 | #endif 29 | 30 | // function based on the article "Using the Clipboard, Part I : Transferring Simple Text" 31 | // by Tom Archer, http://www.codeproject.com/KB/clipboard/archerclipboard1.aspx 32 | inline void SetClipboardString(const WCHAR* wz) 33 | { 34 | if (wz && OpenClipboard(NULL)) 35 | { 36 | // empty the Clipboard. Also allows Windows to free memory for prior contents. 37 | EmptyClipboard(); 38 | 39 | // allocate space for string and NULL-term 40 | HGLOBAL hClipboardData = GlobalAlloc(GMEM_DDESHARE, sizeof(WCHAR)*(wcslen(wz)+1)); 41 | 42 | WCHAR* pchData = (WCHAR*) GlobalLock(hClipboardData); 43 | wcscpy(pchData, wz); 44 | GlobalUnlock(hClipboardData); 45 | 46 | // now, set the Clipboard data, passsing the handle to global memory. 47 | SetClipboardData(CF_UNICODETEXT, hClipboardData); 48 | 49 | // close the Clipboard so that other apps can use it. 50 | CloseClipboard(); 51 | } 52 | } 53 | 54 | inline bool OS_FileExists(const WCHAR* wz) 55 | { 56 | DWORD dwAttributes = GetFileAttributes(wz); 57 | return dwAttributes != UINT_MAX; 58 | } 59 | -------------------------------------------------------------------------------- /src/archive/tools/prev/clipcircle/clipcircle32/icon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/tools/prev/clipcircle/clipcircle32/icon.ico -------------------------------------------------------------------------------- /src/archive/tools/prev/clipcircle/clipcircle32/sendinput.h: -------------------------------------------------------------------------------- 1 | 2 | #pragma once 3 | 4 | bool SendKeyboardInputToWindow(const WCHAR* sz); 5 | -------------------------------------------------------------------------------- /src/archive/tools/prev/gedit_regex_replace/readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/tools/prev/gedit_regex_replace/readme.txt -------------------------------------------------------------------------------- /src/archive/tools/prev/gedit_regex_replace/regex_replace.gedit-plugin: -------------------------------------------------------------------------------- 1 | [Gedit Plugin] 2 | Loader=python 3 | Module=regex_replace 4 | IAge=2 5 | Name=Regex Search and Replace 6 | Description=Text search and replace using regular expressions. 7 | Authors=Daniel d'Andrada T. de Carvalho , Ben Fisher 8 | -------------------------------------------------------------------------------- /src/archive/tools/prev/gedit_regex_replace/regex_replace/__init__.py: -------------------------------------------------------------------------------- 1 | import gedit 2 | import gtk 3 | from regexsearchinstance import RegexSearchInstance 4 | 5 | class RegexSearch(gedit.Plugin): 6 | DATA_TAG = "RegexSearchInstance" 7 | 8 | def __init__(self): 9 | gedit.Plugin.__init__(self) 10 | 11 | def activate(self, window): 12 | regexsearch_instance = RegexSearchInstance(window) 13 | window.set_data(self.DATA_TAG, regexsearch_instance) 14 | 15 | def deactivate(self, window): 16 | regexsearch_instance = window.get_data(self.DATA_TAG) 17 | # regexsearch_instance destroy!? 18 | window.set_data(self.DATA_TAG, None) 19 | 20 | def update_ui(self, window): 21 | regexsearch_instance = window.get_data(self.DATA_TAG) 22 | regexsearch_instance.update_ui() 23 | -------------------------------------------------------------------------------- /src/archive/tools/prev/gedit_regex_replace/regex_replace/regexsearch.gladep: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/tools/prev/simple_source_index/readme.txt -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/sqlite3.dll.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/tools/prev/simple_source_index/sqlite3.dll.zip -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssip.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2012 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simple_source_indexing", "ssip\ssip.vcxproj", "{4E5A72E6-3408-4062-9F23-54209B14FBC9}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {4E5A72E6-3408-4062-9F23-54209B14FBC9}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {4E5A72E6-3408-4062-9F23-54209B14FBC9}.Debug|Win32.Build.0 = Debug|Win32 14 | {4E5A72E6-3408-4062-9F23-54209B14FBC9}.Release|Win32.ActiveCfg = Release|Win32 15 | {4E5A72E6-3408-4062-9F23-54209B14FBC9}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssip/dbaccess.h: -------------------------------------------------------------------------------- 1 | 2 | #pragma once 3 | 4 | #include "util.h" 5 | 6 | // forward declarations to avoid including full sqlite header 7 | typedef struct sqlite3 *psqlite3; 8 | typedef struct sqlite3_stmt *psqlite3_stmt; 9 | 10 | typedef struct SSIdbAccess_t 11 | { 12 | psqlite3 m_db; 13 | psqlite3_stmt* m_stmts; 14 | } SSIdbAccess; 15 | 16 | 17 | SSIdbAccess* SSIdbAccess_Create(const char* szDbName); 18 | void SSIdbAccess_Close(SSIdbAccess* obj); 19 | 20 | SsiE SSIdbAccess_AddSchema(SSIdbAccess* pSSIdbAccess); 21 | SsiE SSIdbAccess_PrepareSqlAll(SSIdbAccess* pDb); 22 | SsiE SSIdbAccess_PrepareSqlQueries(SSIdbAccess* pDb); 23 | SsiE SSIdbAccess_InsertCatalog(SSIdbAccess* pDb, int nHash, int nFileid); 24 | 25 | SsiE SSIdbAccess_InsertSrcFile(SSIdbAccess* pDb, const char* szFile, UINT64 nLastMod, uint* outnId); 26 | SsiE SSIdbAccess_TxnStart(SSIdbAccess* pDb); 27 | SsiE SSIdbAccess_TxnCommit(SSIdbAccess* pDb); 28 | SsiE SSIdbAccess_TxnAbort(SSIdbAccess* pDb); 29 | SsiE SSIdbAccess_AsyncModeStart(SSIdbAccess* pDb); 30 | SsiE SSIdbAccess_AsyncModeStop(SSIdbAccess* pDb); 31 | SsiE SSIdbAccess_AddCatalogSrcIndex(SSIdbAccess* pDb); 32 | 33 | SsiE SSIdbAccess_GetLastModified(SSIdbAccess* pDb, const char* szFile, UINT64*outnLastMod, uint*outnRowId); 34 | SsiE SSIdbAccess_DeleteFromCatalogWhereSrcId(SSIdbAccess* pDb, uint nRowId); 35 | SsiE SSIdbAccess_UpdateLastModified(SSIdbAccess* pDb, uint nRowId, UINT64 lastmodactual); 36 | SsiE SSIdbAccess_CountFileRows(SSIdbAccess* pDb, uint* nFileRows); 37 | 38 | typedef bool(*PfnQueryCatalogCallback)(void* context, const char* szFilename, const char* szSearch); 39 | SsiE SSIdbAccess_QueryCatalog(SSIdbAccess* pdbAccess, int nHash, const char* szWord, PfnQueryCatalogCallback pfn, void* context); 40 | 41 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssip/hash.h: -------------------------------------------------------------------------------- 1 | 2 | // S-Box hash. 3 | // From http://www.team5150.com/~andrew/noncryptohashzoo/SBox.html 4 | // Sbox originally by Bret Mulvey, modified by Andrew @ Team5150. 5 | // Modified by Ben Fisher to support streaming (when string length not known in advance) 6 | 7 | #pragma once 8 | #include "util.h" 9 | 10 | typedef unsigned int u32; 11 | // table used by hash algorithm 12 | extern u32* SBoxTable; 13 | // arbitrary constant for hash 14 | const int nHashseed = 0x9dce366b; 15 | 16 | // used to truncate the result to 24bits 17 | #ifndef Test_SmallBuffer 18 | #define Hash_tmpMask 0x00ffffff 19 | #else 20 | #define Hash_tmpMask 0x000000ff 21 | #endif 22 | 23 | // Use these macros to hash a string one character at a time. 24 | // see Hash_getHashValue for example usage. 25 | // the value is not valid until Hash_Finalize is called. 26 | #define Hash_Reset(h) do {(h) = nHashseed;} while (0) 27 | #define Hash_AddChar(h, c) do {(h) = ((h) ^ SBoxTable[(c)] ) * 3; } while (0) 28 | #define Hash_Finalize(h, len) do {(h) += ((h) >> 22 ) ^ ((h) << 4 ); (h)+=(u32)(len); (h)&=Hash_tmpMask; } while (0) 29 | 30 | // get hash value of a string, if the entire string is known. 31 | inline u32 Hash_getHashValue(const char* s) 32 | { 33 | size_t len = strlen(s); 34 | u32 h = 0; 35 | Hash_Reset(h); 36 | for (size_t i=0; im_errFlag = SsiEOk; 24 | obj->m_szIniFile = strdup(szIniFile); 25 | obj->m_szDbFile = null; 26 | obj->m_dbAccess = null; 27 | obj->m_bFullUpdate = false; 28 | obj->m_bVerbose = false; 29 | obj->m_nFilesPresent = 0; 30 | obj->m_nMinWordlen = 5; 31 | return obj; 32 | } 33 | inline void SsipIndexer_Close(SsipIndexer* obj) 34 | { 35 | if (!obj) return; 36 | free_nop(obj->m_errFlag); 37 | free_free(obj->m_szIniFile); 38 | free_free(obj->m_szDbFile); 39 | free_fn(obj->m_dbAccess, SSIdbAccess_Close); 40 | free_nop(obj->m_bFullUpdate); 41 | free_nop(obj->m_bVerbose); 42 | free_nop(obj->m_nFilesPresent); 43 | free_nop(obj->m_nMinWordlen); 44 | free_free(obj); 45 | } 46 | 47 | void SipHigh_RunUpdate(const char* szIni, bool bFullupdate); 48 | void SipHigh_FindInFiles(const char* szIni, const char* szTerm, bool bWholeWord); 49 | void SipHigh_RunSearch(const char* szIni, const char* szTerm); 50 | 51 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssip/sqlite3.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/archive/tools/prev/simple_source_index/ssip/sqlite3.lib -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssip/text.h: -------------------------------------------------------------------------------- 1 | 2 | #pragma once 3 | 4 | #include "util.h" 5 | #include "dbaccess.h" 6 | 7 | void text_init(); 8 | void text_uninit(); 9 | 10 | bool text_checkIsBlacklisted(const char* s); 11 | SsiE text_processFile(SSIdbAccess* pDbAccess, const char* szFilename, uint nFileid, uint nMinWordlen); 12 | SsiE text_findinfile(const char* szFilename, const char* szSearchString, bool bWholeWord, bool bExpectToFind); 13 | 14 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/ssipexample.cfg: -------------------------------------------------------------------------------- 1 | 2 | [main] 3 | 4 | srcdir1=C:\path\to\my\sourcecode 5 | srcdir2= 6 | srcdir3= 7 | 8 | 9 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/test/testdata/folder1/contrived.cpp: -------------------------------------------------------------------------------- 1 | wantstring typedef struct 2 | { 3 | bool isFile; wantstring 4 | FILE * f; char* mem; 5 | size_t position; 6 | int n; CAudioData_donot hit 7 | } Simplestream; 8 | 9 | 10 | size_t gfwrite ( const void * ptr, size_t size, size_t count, Simplestream * stream ) 11 | { 12 | wantstring if (stream->isFile) 13 | wantstring if (stream->isFile) same twice wantstring 14 | return fwrite( ptr, size, count, stream->f); notCAudioData 15 | else 16 | a wantstring { also twice wantstring and again wantstring sdf 17 | memcpy(stream->mem + stream->position, ptr, count*size); 18 | stream->position += count*size; notCAudioDatanot 19 | return count*size; 20 | } 21 | } wantstring -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/test/testdata/folder1/notsour.ce: -------------------------------------------------------------------------------- 1 | // Wave Persistence 2 | 3 | #include "bcaudio.h" 4 | #include "wav_persist.h" 5 | 6 | 7 | // The goal is to use the same code when writing to memory and writing to disk. 8 | // So, we have to use a type of polymorphism, which in C is not very pretty. 9 | 10 | 11 | typedef struct 12 | { 13 | bool isFile; 14 | FILE * f; char* mem; 15 | size_t position; 16 | } Simplestream; 17 | 18 | 19 | size_t gfwrite ( const void * ptr, size_t size, size_t count, Simplestream * stream ) 20 | { 21 | if (stream->isFile) 22 | return fwrite( ptr, size, count, stream->f); 23 | else 24 | { 25 | memcpy(stream->mem + stream->position, ptr, count*size); 26 | stream->position += count*size; 27 | return count*size; 28 | } 29 | } 30 | notsourcesearch 31 | int gfputc ( int character, Simplestream * stream ) 32 | { 33 | if (stream->isFile) 34 | return fputc( character, stream->f); 35 | else 36 | { 37 | stream->mem[stream->position] = (char) character; 38 | stream->position += 1; 39 | return 1; 40 | } 41 | } 42 | 43 | 44 | -------------------------------------------------------------------------------- /src/archive/tools/prev/simple_source_index/test/testdata/folder1/notsource.c.not: -------------------------------------------------------------------------------- 1 | // Wave Persistence 2 | 3 | #include "bcaudio.h" 4 | #include "wav_persist.h" 5 | 6 | 7 | // The goal is to use the same code when writing to memory and writing to disk. 8 | // So, we have to use a type of polymorphism, which in C is not very pretty. 9 | 10 | 11 | typedef struct 12 | { 13 | bool isFile; 14 | FILE * f; char* mem; 15 | size_t position; 16 | } Simplestream; 17 | 18 | 19 | size_t gfwrite ( const void * ptr, size_t size, size_t count, Simplestream * stream ) 20 | { 21 | if (stream->isFile) 22 | return fwrite( ptr, size, count, stream->f); 23 | else 24 | { 25 | memcpy(stream->mem + stream->position, ptr, count*size); 26 | stream->position += count*size; 27 | return count*size; 28 | } 29 | } 30 | notsourcesearch 31 | int gfputc ( int character, Simplestream * stream ) 32 | { 33 | if (stream->isFile) 34 | return fputc( character, stream->f); 35 | else 36 | { 37 | stream->mem[stream->position] = (char) character; 38 | stream->position += 1; 39 | return 1; 40 | } 41 | } 42 | 43 | 44 | -------------------------------------------------------------------------------- /src/archive/tools/prev/wrappers/mysha1.py: -------------------------------------------------------------------------------- 1 | #Ben Fisher, GPL 2 | # 3 | #This program is distributed in the hope that it will be useful, 4 | #but without any warranty. 5 | 6 | import hashlib 7 | 8 | def gethash(file): 9 | if False: 10 | print('md5') 11 | objHash = hashlib.md5() 12 | else: 13 | print('sha1') 14 | objHash = hashlib.sha1() 15 | 16 | f=open(file,'rb') 17 | while 1: 18 | buf = f.read(4096) 19 | if not buf : break 20 | objHash.update(hashlib.sha1(buf).hexdigest()) 21 | 22 | f.close() 23 | print(objHash.hexdigest()) 24 | 25 | if __name__=='__main__': 26 | import os, sys 27 | for arg in sys.argv[1:]: 28 | print(arg) 29 | gethash(arg) 30 | 31 | os.system('pause') 32 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/SciTE.properties: -------------------------------------------------------------------------------- 1 | 2 | command.compile.$(file.patterns.cpp)="C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for Python\9.0\vcvarsall.bat" && nmake -f WinCommonDialog.mak all 3 | command.clean.$(file.patterns.cpp)="C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for Python\9.0\vcvarsall.bat" && nmake -f WinCommonDialog.mak clean 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/dialog_color.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "utils.h" 3 | #include 4 | 5 | const char* documentationColor = 6 | "WinCommonDialog color\n" 7 | "(Returns result through stdout.)\n" 8 | "\n" 9 | "Displays dialog where user can choose color.\n" 10 | "The result red, green, blue is printed to stdout, each are numbers in decimal.\n" 11 | "Returns \"|color_cancel|\" if user cancels.\n"; 12 | 13 | 14 | 15 | int dialog_color(int argc, _TCHAR* argv[]) 16 | { 17 | if (argc > 1 && stringsEqual(argv[1], _T("/?"))) 18 | { 19 | puts(documentationColor); 20 | return 1; 21 | } 22 | 23 | COLORREF acrCustClr[16] = {0}; // array of custom colors 24 | DWORD rgbCurrent = 0; // initial color (black) 25 | 26 | CHOOSECOLOR cc = {0}; 27 | cc.lStructSize = sizeof(cc); 28 | cc.hwndOwner = NULL; 29 | cc.lpCustColors = (LPDWORD) acrCustClr; 30 | cc.rgbResult = rgbCurrent; 31 | cc.Flags = CC_FULLOPEN | CC_RGBINIT; 32 | 33 | if (ChooseColor(&cc)) 34 | { 35 | rgbCurrent = cc.rgbResult; 36 | 37 | int r = (int) GetRValue(rgbCurrent); 38 | int g = (int) GetGValue(rgbCurrent); 39 | int b = (int) GetBValue(rgbCurrent); 40 | wprintf(L"|color|%d|%d|%d|", r, g, b); 41 | } 42 | else 43 | { 44 | traceString(L"|color_cancel|"); 45 | } 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/dialog_sound.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "utils.h" 3 | #include 4 | 5 | const char* documentationSound = 6 | "WinCommonDialog sound soundname\n" 7 | "(Returns exit code 0 on success, 1 on failure.)\n" 8 | "\n" 9 | "soundname can be path to .wav file\n" 10 | "or one of:\n" 11 | "'Asterisk' 'Default' 'Exclamation' 'Question'"; 12 | 13 | 14 | int dialog_sound(int argc, _TCHAR* argv[]) 15 | { 16 | LPCTSTR soundname = getArgument(1, argc, argv); 17 | if (!soundname) 18 | { 19 | puts(documentationSound); 20 | return 1; 21 | } 22 | 23 | // don't specify SND_ASYNC because this process will likely close before playback. 24 | LPCTSTR soundalias = NULL; 25 | DWORD flags = 0; 26 | BOOL result = FALSE; 27 | 28 | if (stringsEqual(soundname, _T("Asterisk"))) 29 | { 30 | soundalias = (LPCTSTR)SND_ALIAS_SYSTEMASTERISK; 31 | } 32 | else if (stringsEqual(soundname, _T("Default"))) 33 | { 34 | soundalias = (LPCTSTR)SND_ALIAS_SYSTEMDEFAULT; 35 | } 36 | else if (stringsEqual(soundname, _T("Exclamation"))) 37 | { 38 | soundalias = (LPCTSTR)SND_ALIAS_SYSTEMEXCLAMATION; 39 | } 40 | else if (stringsEqual(soundname, _T("Question"))) 41 | { 42 | soundalias = (LPCTSTR)SND_ALIAS_SYSTEMQUESTION; 43 | } 44 | 45 | if (soundalias) 46 | { 47 | result = PlaySound(soundalias, NULL, flags | SND_ALIAS_ID); 48 | } 49 | else 50 | { 51 | result = PlaySound(soundname, NULL, flags | SND_FILENAME); 52 | } 53 | 54 | // returns exit code 0 on success, 1 on failure. 55 | return result ? 0 : 1; 56 | } 57 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/readme.txt: -------------------------------------------------------------------------------- 1 | 2 | WinCommonDialog.exe, Ben Fisher 2008, 3 | GPL v3 4 | A wrapper over simple Windows dialogs, using return code to pass result. 5 | https://github.com/moltenform/scite-with-python 6 | 7 | This is divided into different functions. For details, use one of the following, 8 | WinCommonDialog simple /? 9 | WinCommonDialog color /? 10 | WinCommonDialog file /? 11 | WinCommonDialog sound /? 12 | WinCommonDialog text /? 13 | 14 | Building 15 | This tool doesn't have to be build with a specific compiler, but it makes sense to use msvc 9.0 because 16 | scite-with-python already has a dependency on that c runtime. 17 | It's the same c runtime that will be installed when python 2.7 is installed. 18 | 19 | - Install compiler 20 | Microsoft Visual C++ Compiler for Python 2.7 21 | Freely available at https://www.microsoft.com/en-us/download/confirmation.aspx?id=44266 22 | Download VCForPython27.msi, 23 | then in an admin prompt, run 24 | msiexec /i VCForPython27.msi ALLUSERS=1 25 | The package will be installed to C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for Python\9.0 26 | 27 | - Build WinCommonDialog 28 | Open a command prompt 29 | cd to C:\Program Files (x86)\Common Files\Microsoft\Visual C++ for Python\9.0 30 | run vcvarsall.bat 31 | cd to WinCommonDialog 32 | run nmake -f WinCommonDialog.mak all 33 | 34 | 35 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/resource.h: -------------------------------------------------------------------------------- 1 | #define IDD_DIALOG1 102 2 | #define IDC_EDIT1 110 3 | #define IDC_THESTATIC1 111 4 | 5 | -------------------------------------------------------------------------------- /src/archive/tools/wincommondialog/WinCommonDialog/utils.h: -------------------------------------------------------------------------------- 1 | 2 | #define WIN32_LEAN_AND_MEAN 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | void replaceCharWithNulChar(std::wstring& str, WCHAR ch); 9 | 10 | _TCHAR* getArgument(int index, int argc, _TCHAR** argv); 11 | 12 | bool stringsEqual(const _TCHAR* s1, const _TCHAR* s2); 13 | 14 | size_t stringLength(const _TCHAR* s1); 15 | 16 | void traceString(const _TCHAR* s1, bool newline = false); 17 | 18 | std::wstring GetDlgItemText(HWND dlg, int itemId, DWORD& lastError); 19 | -------------------------------------------------------------------------------- /src/dloadlin.md: -------------------------------------------------------------------------------- 1 | 2 | Back 3 | 4 | ### Download (Linux) 5 | 6 | run the following in a terminal, 7 | 8 | sudo apt-get install libgtk2.0-dev 9 | sudo apt-get install python2.7-dev 10 | sudo apt-get install xclip 11 | 12 | cd ~/Downloads 13 | wget https://github.com/moltenform/scite-with-python/archive/v0.7.4.tar.gz 14 | tar -xzf v0.7.4.tar.gz 15 | cd scite-with-python-0.7.4/src/scite/scintilla/gtk 16 | make 17 | 18 | cd ../../scite/gtk 19 | make 20 | sudo make install 21 | 22 | SciTE_with_python 23 | 24 |

 

Back 25 | -------------------------------------------------------------------------------- /src/dloadwin.md: -------------------------------------------------------------------------------- 1 | 2 | Back 3 | 4 | ### Download (Windows) 5 | 6 | * unless you already have Python 2.7 installed, install [Python 2.7](https://www.python.org/downloads/windows/), use the Windows x86 MSI installer 7 | 8 | * download [scite_with_python_0_7_4_win32.zip](https://github.com/moltenform/scite-with-python/releases/download/v0.7.4/scite_with_python_0_7_4_win32.zip) 9 | 10 | * unzip scite_with_python_0_7_4_win32.zip 11 | 12 | * open SciTE.exe 13 | 14 | * (optional: build from source) 15 | 16 |

 

Back 17 | -------------------------------------------------------------------------------- /src/scite/Documentation.txt: -------------------------------------------------------------------------------- 1 | 2 | SciTE-with-Python 3 | By Ben Fisher, 2017 4 | 5 | The documentation for this project can be found online at 6 | https://github.com/moltenform/scite-with-python 7 | 8 | -------------------------------------------------------------------------------- /src/scite/License-SciTE: -------------------------------------------------------------------------------- 1 | License for Scintilla and SciTE 2 | 3 | Copyright 1998-2003 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. -------------------------------------------------------------------------------- /src/scite/License-Scintilla: -------------------------------------------------------------------------------- 1 | License for Scintilla and SciTE 2 | 3 | Copyright 1998-2003 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. -------------------------------------------------------------------------------- /src/scite/empty.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/empty.md -------------------------------------------------------------------------------- /src/scite/scintilla/bin/empty.txt: -------------------------------------------------------------------------------- 1 | This empty files ensures that the directory is created. -------------------------------------------------------------------------------- /src/scite/scintilla/doc/Indicators.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/Indicators.png -------------------------------------------------------------------------------- /src/scite/scintilla/doc/Markers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/Markers.png -------------------------------------------------------------------------------- /src/scite/scintilla/doc/SciBreak.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/SciBreak.jpg -------------------------------------------------------------------------------- /src/scite/scintilla/doc/SciRest.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/SciRest.jpg -------------------------------------------------------------------------------- /src/scite/scintilla/doc/SciTEIco.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/SciTEIco.png -------------------------------------------------------------------------------- /src/scite/scintilla/doc/SciWord.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/SciWord.jpg -------------------------------------------------------------------------------- /src/scite/scintilla/doc/annotations.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/annotations.png -------------------------------------------------------------------------------- /src/scite/scintilla/doc/styledmargin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/doc/styledmargin.png -------------------------------------------------------------------------------- /src/scite/scintilla/gtk/scintilla-marshal.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __scintilla_marshal_MARSHAL_H__ 3 | #define __scintilla_marshal_MARSHAL_H__ 4 | 5 | #include 6 | 7 | G_BEGIN_DECLS 8 | 9 | /* NONE:INT,OBJECT (scintilla-marshal.list:1) */ 10 | extern void scintilla_marshal_VOID__INT_OBJECT (GClosure *closure, 11 | GValue *return_value, 12 | guint n_param_values, 13 | const GValue *param_values, 14 | gpointer invocation_hint, 15 | gpointer marshal_data); 16 | #define scintilla_marshal_NONE__INT_OBJECT scintilla_marshal_VOID__INT_OBJECT 17 | 18 | /* NONE:INT,BOXED (scintilla-marshal.list:2) */ 19 | extern void scintilla_marshal_VOID__INT_BOXED (GClosure *closure, 20 | GValue *return_value, 21 | guint n_param_values, 22 | const GValue *param_values, 23 | gpointer invocation_hint, 24 | gpointer marshal_data); 25 | #define scintilla_marshal_NONE__INT_BOXED scintilla_marshal_VOID__INT_BOXED 26 | 27 | G_END_DECLS 28 | 29 | #endif /* __scintilla_marshal_MARSHAL_H__ */ 30 | 31 | -------------------------------------------------------------------------------- /src/scite/scintilla/gtk/scintilla-marshal.list: -------------------------------------------------------------------------------- 1 | NONE:INT,OBJECT 2 | NONE:INT,BOXED 3 | -------------------------------------------------------------------------------- /src/scite/scintilla/include/Sci_Position.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file Sci_Position.h 3 | ** Define the Sci_Position type used in Scintilla's external interfaces. 4 | ** These need to be available to clients written in C so are not in a C++ namespace. 5 | **/ 6 | // Copyright 2015 by Neil Hodgson 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | #ifndef SCI_POSITION_H 10 | #define SCI_POSITION_H 11 | 12 | // Basic signed type used throughout interface 13 | typedef int Sci_Position; 14 | 15 | // Unsigned variant used for ILexer::Lex and ILexer::Fold 16 | typedef unsigned int Sci_PositionU; 17 | 18 | // For Sci_CharacterRange which is defined as long to be compatible with Win32 CHARRANGE 19 | typedef long Sci_PositionCR; 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexers/LexCSS.cxx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/lexers/LexCSS.cxx -------------------------------------------------------------------------------- /src/scite/scintilla/lexers/LexErlang.cxx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/lexers/LexErlang.cxx -------------------------------------------------------------------------------- /src/scite/scintilla/lexers/LexMMIXAL.cxx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/lexers/LexMMIXAL.cxx -------------------------------------------------------------------------------- /src/scite/scintilla/lexers/LexMatlab.cxx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scintilla/lexers/LexMatlab.cxx -------------------------------------------------------------------------------- /src/scite/scintilla/lexers/LexNull.cxx: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file LexNull.cxx 3 | ** Lexer for no language. Used for plain text and unrecognized files. 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 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "ILexer.h" 16 | #include "Scintilla.h" 17 | #include "SciLexer.h" 18 | 19 | #include "WordList.h" 20 | #include "LexAccessor.h" 21 | #include "Accessor.h" 22 | #include "StyleContext.h" 23 | #include "CharacterSet.h" 24 | #include "LexerModule.h" 25 | 26 | #ifdef SCI_NAMESPACE 27 | using namespace Scintilla; 28 | #endif 29 | 30 | static void ColouriseNullDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], 31 | Accessor &styler) { 32 | // Null language means all style bytes are 0 so just mark the end - no need to fill in. 33 | if (length > 0) { 34 | styler.StartAt(startPos + length - 1); 35 | styler.StartSegment(startPos + length - 1); 36 | styler.ColourTo(startPos + length - 1, 0); 37 | } 38 | } 39 | 40 | LexerModule lmNull(SCLEX_NULL, ColouriseNullDoc, "null"); 41 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/Accessor.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file Accessor.h 3 | ** Interfaces between Scintilla and lexers. 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 ACCESSOR_H 9 | #define ACCESSOR_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | enum { wsSpace=1, wsTab=2, wsSpaceTab=4, wsInconsistent=8 }; 16 | 17 | class Accessor; 18 | class WordList; 19 | class PropSetSimple; 20 | 21 | typedef bool (*PFNIsCommentLeader)(Accessor &styler, Sci_Position pos, Sci_Position len); 22 | 23 | class Accessor : public LexAccessor { 24 | public: 25 | PropSetSimple *pprops; 26 | Accessor(IDocument *pAccess_, PropSetSimple *pprops_); 27 | int GetPropertyInt(const char *, int defaultValue=0) const; 28 | int IndentAmount(Sci_Position line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0); 29 | }; 30 | 31 | #ifdef SCI_NAMESPACE 32 | } 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/CharacterCategory.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file CharacterCategory.h 3 | ** Returns the Unicode general category of a character. 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 CHARACTERCATEGORY_H 9 | #define CHARACTERCATEGORY_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | enum CharacterCategory { 16 | ccLu, ccLl, ccLt, ccLm, ccLo, 17 | ccMn, ccMc, ccMe, 18 | ccNd, ccNl, ccNo, 19 | ccPc, ccPd, ccPs, ccPe, ccPi, ccPf, ccPo, 20 | ccSm, ccSc, ccSk, ccSo, 21 | ccZs, ccZl, ccZp, 22 | ccCc, ccCf, ccCs, ccCo, ccCn 23 | }; 24 | 25 | CharacterCategory CategoriseCharacter(int character); 26 | 27 | #ifdef SCI_NAMESPACE 28 | } 29 | #endif 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/CharacterSet.cxx: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file CharacterSet.cxx 3 | ** Simple case functions for ASCII. 4 | ** Lexer infrastructure. 5 | **/ 6 | // Copyright 1998-2010 by Neil Hodgson 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "CharacterSet.h" 16 | 17 | #ifdef SCI_NAMESPACE 18 | using namespace Scintilla; 19 | #endif 20 | 21 | #ifdef SCI_NAMESPACE 22 | namespace Scintilla { 23 | #endif 24 | 25 | int CompareCaseInsensitive(const char *a, const char *b) { 26 | while (*a && *b) { 27 | if (*a != *b) { 28 | char upperA = MakeUpperCase(*a); 29 | char upperB = MakeUpperCase(*b); 30 | if (upperA != upperB) 31 | return upperA - upperB; 32 | } 33 | a++; 34 | b++; 35 | } 36 | // Either *a or *b is nul 37 | return *a - *b; 38 | } 39 | 40 | int CompareNCaseInsensitive(const char *a, const char *b, size_t len) { 41 | while (*a && *b && len) { 42 | if (*a != *b) { 43 | char upperA = MakeUpperCase(*a); 44 | char upperB = MakeUpperCase(*b); 45 | if (upperA != upperB) 46 | return upperA - upperB; 47 | } 48 | a++; 49 | b++; 50 | len--; 51 | } 52 | if (len == 0) 53 | return 0; 54 | else 55 | // Either *a or *b is nul 56 | return *a - *b; 57 | } 58 | 59 | #ifdef SCI_NAMESPACE 60 | } 61 | #endif 62 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/LexerBase.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file LexerBase.h 3 | ** A simple lexer with no state. 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 LEXERBASE_H 9 | #define LEXERBASE_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | // A simple lexer with no state 16 | class LexerBase : public ILexer { 17 | protected: 18 | PropSetSimple props; 19 | enum {numWordLists=KEYWORDSET_MAX+1}; 20 | WordList *keyWordLists[numWordLists+1]; 21 | public: 22 | LexerBase(); 23 | virtual ~LexerBase(); 24 | void SCI_METHOD Release(); 25 | int SCI_METHOD Version() const; 26 | const char * SCI_METHOD PropertyNames(); 27 | int SCI_METHOD PropertyType(const char *name); 28 | const char * SCI_METHOD DescribeProperty(const char *name); 29 | Sci_Position SCI_METHOD PropertySet(const char *key, const char *val); 30 | const char * SCI_METHOD DescribeWordListSets(); 31 | Sci_Position SCI_METHOD WordListSet(int n, const char *wl); 32 | void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0; 33 | void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0; 34 | void * SCI_METHOD PrivateCall(int operation, void *pointer); 35 | }; 36 | 37 | #ifdef SCI_NAMESPACE 38 | } 39 | #endif 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/LexerNoExceptions.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file LexerNoExceptions.h 3 | ** A simple lexer with no state. 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 LEXERNOEXCEPTIONS_H 9 | #define LEXERNOEXCEPTIONS_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | // A simple lexer with no state 16 | class LexerNoExceptions : public LexerBase { 17 | public: 18 | // TODO Also need to prevent exceptions in constructor and destructor 19 | Sci_Position SCI_METHOD PropertySet(const char *key, const char *val); 20 | Sci_Position SCI_METHOD WordListSet(int n, const char *wl); 21 | void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess); 22 | void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *); 23 | 24 | virtual void Lexer(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess, Accessor &styler) = 0; 25 | virtual void Folder(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess, Accessor &styler) = 0; 26 | }; 27 | 28 | #ifdef SCI_NAMESPACE 29 | } 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/LexerSimple.cxx: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file LexerSimple.cxx 3 | ** A simple lexer with no state. 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 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include 16 | 17 | #include "ILexer.h" 18 | #include "Scintilla.h" 19 | #include "SciLexer.h" 20 | 21 | #include "PropSetSimple.h" 22 | #include "WordList.h" 23 | #include "LexAccessor.h" 24 | #include "Accessor.h" 25 | #include "LexerModule.h" 26 | #include "LexerBase.h" 27 | #include "LexerSimple.h" 28 | 29 | #ifdef SCI_NAMESPACE 30 | using namespace Scintilla; 31 | #endif 32 | 33 | LexerSimple::LexerSimple(const LexerModule *module_) : module(module_) { 34 | for (int wl = 0; wl < module->GetNumWordLists(); wl++) { 35 | if (!wordLists.empty()) 36 | wordLists += "\n"; 37 | wordLists += module->GetWordListDescription(wl); 38 | } 39 | } 40 | 41 | const char * SCI_METHOD LexerSimple::DescribeWordListSets() { 42 | return wordLists.c_str(); 43 | } 44 | 45 | void SCI_METHOD LexerSimple::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) { 46 | Accessor astyler(pAccess, &props); 47 | module->Lex(startPos, lengthDoc, initStyle, keyWordLists, astyler); 48 | astyler.Flush(); 49 | } 50 | 51 | void SCI_METHOD LexerSimple::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) { 52 | if (props.GetInt("fold")) { 53 | Accessor astyler(pAccess, &props); 54 | module->Fold(startPos, lengthDoc, initStyle, keyWordLists, astyler); 55 | astyler.Flush(); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/LexerSimple.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file LexerSimple.h 3 | ** A simple lexer with no state. 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 LEXERSIMPLE_H 9 | #define LEXERSIMPLE_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | // A simple lexer with no state 16 | class LexerSimple : public LexerBase { 17 | const LexerModule *module; 18 | std::string wordLists; 19 | public: 20 | explicit LexerSimple(const LexerModule *module_); 21 | const char * SCI_METHOD DescribeWordListSets(); 22 | void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess); 23 | void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess); 24 | }; 25 | 26 | #ifdef SCI_NAMESPACE 27 | } 28 | #endif 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/PropSetSimple.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file PropSetSimple.h 3 | ** A basic string to string map. 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 PROPSETSIMPLE_H 9 | #define PROPSETSIMPLE_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | class PropSetSimple { 16 | void *impl; 17 | void Set(const char *keyVal); 18 | public: 19 | PropSetSimple(); 20 | virtual ~PropSetSimple(); 21 | void Set(const char *key, const char *val, int lenKey=-1, int lenVal=-1); 22 | void SetMultiple(const char *); 23 | const char *Get(const char *key) const; 24 | int GetExpanded(const char *key, char *result) const; 25 | int GetInt(const char *key, int defaultValue=0) const; 26 | }; 27 | 28 | #ifdef SCI_NAMESPACE 29 | } 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/StringCopy.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file StringCopy.h 3 | ** Safe string copy function which always NUL terminates. 4 | ** ELEMENTS macro for determining array sizes. 5 | **/ 6 | // Copyright 2013 by Neil Hodgson 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | #ifndef STRINGCOPY_H 10 | #define STRINGCOPY_H 11 | 12 | #ifdef SCI_NAMESPACE 13 | namespace Scintilla { 14 | #endif 15 | 16 | // Safer version of string copy functions like strcpy, wcsncpy, etc. 17 | // Instantiate over fixed length strings of both char and wchar_t. 18 | // May truncate if source doesn't fit into dest with room for NUL. 19 | 20 | template 21 | void StringCopy(T (&dest)[count], const T* source) { 22 | for (size_t i=0; i 6 | // This file is in the public domain. 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include "ILexer.h" 15 | 16 | #include "LexAccessor.h" 17 | #include "Accessor.h" 18 | #include "StyleContext.h" 19 | 20 | #ifdef SCI_NAMESPACE 21 | using namespace Scintilla; 22 | #endif 23 | 24 | static void getRange(Sci_PositionU start, 25 | Sci_PositionU end, 26 | LexAccessor &styler, 27 | char *s, 28 | Sci_PositionU len) { 29 | Sci_PositionU i = 0; 30 | while ((i < end - start + 1) && (i < len-1)) { 31 | s[i] = styler[start + i]; 32 | i++; 33 | } 34 | s[i] = '\0'; 35 | } 36 | 37 | void StyleContext::GetCurrent(char *s, Sci_PositionU len) { 38 | getRange(styler.GetStartSegment(), currentPos - 1, styler, s, len); 39 | } 40 | 41 | static void getRangeLowered(Sci_PositionU start, 42 | Sci_PositionU end, 43 | LexAccessor &styler, 44 | char *s, 45 | Sci_PositionU len) { 46 | Sci_PositionU i = 0; 47 | while ((i < end - start + 1) && (i < len-1)) { 48 | s[i] = static_cast(tolower(styler[start + i])); 49 | i++; 50 | } 51 | s[i] = '\0'; 52 | } 53 | 54 | void StyleContext::GetCurrentLowered(char *s, Sci_PositionU len) { 55 | getRangeLowered(styler.GetStartSegment(), currentPos - 1, styler, s, len); 56 | } 57 | -------------------------------------------------------------------------------- /src/scite/scintilla/lexlib/WordList.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file WordList.h 3 | ** Hold a list of words. 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 WORDLIST_H 9 | #define WORDLIST_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | /** 16 | */ 17 | class WordList { 18 | // Each word contains at least one character - a empty word acts as sentinel at the end. 19 | char **words; 20 | char *list; 21 | int len; 22 | bool onlyLineEnds; ///< Delimited by any white space or only line ends 23 | int starts[256]; 24 | public: 25 | explicit WordList(bool onlyLineEnds_ = false); 26 | ~WordList(); 27 | operator bool() const; 28 | bool operator!=(const WordList &other) const; 29 | int Length() const; 30 | void Clear(); 31 | void Set(const char *s); 32 | bool InList(const char *s) const; 33 | bool InListAbbreviated(const char *s, const char marker) const; 34 | const char *WordAt(int n) const; 35 | }; 36 | 37 | #ifdef SCI_NAMESPACE 38 | } 39 | #endif 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /src/scite/scintilla/scripts/GenerateCharacterCategory.py: -------------------------------------------------------------------------------- 1 | # Script to generate CharacterCategory.cxx from Python's Unicode data 2 | # Should be run rarely when a Python with a new version of Unicode data is available. 3 | # Requires Python 3.3 or later 4 | # Should not be run with old versions of Python. 5 | 6 | import codecs, os, platform, sys, unicodedata 7 | 8 | from FileGenerator import Regenerate 9 | 10 | def findCategories(filename): 11 | with codecs.open(filename, "r", "UTF-8") as infile: 12 | lines = [x.strip() for x in infile.readlines() if "\tcc" in x] 13 | values = "".join(lines).replace(" ","").split(",") 14 | print(values) 15 | return [v[2:] for v in values] 16 | 17 | def updateCharacterCategory(filename): 18 | values = ["// Created with Python %s, Unicode %s" % ( 19 | platform.python_version(), unicodedata.unidata_version)] 20 | category = unicodedata.category(chr(0)) 21 | startRange = 0 22 | for ch in range(sys.maxunicode): 23 | uch = chr(ch) 24 | if unicodedata.category(uch) != category: 25 | value = startRange * 32 + categories.index(category) 26 | values.append("%d," % value) 27 | category = unicodedata.category(uch) 28 | startRange = ch 29 | value = startRange * 32 + categories.index(category) 30 | values.append("%d," % value) 31 | 32 | Regenerate(filename, "//", values) 33 | 34 | categories = findCategories("../lexlib/CharacterCategory.h") 35 | 36 | updateCharacterCategory("../lexlib/CharacterCategory.cxx") 37 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/CaseConvert.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | // Encoding: UTF-8 3 | /** @file CaseConvert.h 4 | ** Performs Unicode case conversions. 5 | ** Does not handle locale-sensitive case conversion. 6 | **/ 7 | // Copyright 2013 by Neil Hodgson 8 | // The License.txt file describes the conditions under which this software may be distributed. 9 | 10 | #ifndef CASECONVERT_H 11 | #define CASECONVERT_H 12 | 13 | #ifdef SCI_NAMESPACE 14 | namespace Scintilla { 15 | #endif 16 | 17 | enum CaseConversion { 18 | CaseConversionFold, 19 | CaseConversionUpper, 20 | CaseConversionLower 21 | }; 22 | 23 | class ICaseConverter { 24 | public: 25 | virtual size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) = 0; 26 | }; 27 | 28 | ICaseConverter *ConverterFor(enum CaseConversion conversion); 29 | 30 | // Returns a UTF-8 string. Empty when no conversion 31 | const char *CaseConvert(int character, enum CaseConversion conversion); 32 | 33 | // When performing CaseConvertString, the converted value may be up to 3 times longer than the input. 34 | // Ligatures are often decomposed into multiple characters and long cases include: 35 | // ΐ "\xce\x90" folds to ΐ "\xce\xb9\xcc\x88\xcc\x81" 36 | const int maxExpansionCaseConversion=3; 37 | 38 | // Converts a mixed case string using a particular conversion. 39 | // Result may be a different length to input and the length is the return value. 40 | // If there is not enough space then 0 is returned. 41 | size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, enum CaseConversion conversion); 42 | 43 | #ifdef SCI_NAMESPACE 44 | } 45 | #endif 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/CaseFolder.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file CaseFolder.h 3 | ** Classes for case folding. 4 | **/ 5 | // Copyright 1998-2013 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef CASEFOLDER_H 9 | #define CASEFOLDER_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | class CaseFolder { 16 | public: 17 | virtual ~CaseFolder(); 18 | virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) = 0; 19 | }; 20 | 21 | class CaseFolderTable : public CaseFolder { 22 | protected: 23 | char mapping[256]; 24 | public: 25 | CaseFolderTable(); 26 | virtual ~CaseFolderTable(); 27 | virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed); 28 | void SetTranslation(char ch, char chTranslation); 29 | void StandardASCII(); 30 | }; 31 | 32 | class ICaseConverter; 33 | 34 | class CaseFolderUnicode : public CaseFolderTable { 35 | ICaseConverter *converter; 36 | public: 37 | CaseFolderUnicode(); 38 | virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed); 39 | }; 40 | 41 | #ifdef SCI_NAMESPACE 42 | } 43 | #endif 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/Catalogue.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file Catalogue.h 3 | ** Lexer infrastructure. 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 CATALOGUE_H 9 | #define CATALOGUE_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | class Catalogue { 16 | public: 17 | static const LexerModule *Find(int language); 18 | static const LexerModule *Find(const char *languageName); 19 | static void AddLexerModule(LexerModule *plm); 20 | }; 21 | 22 | #ifdef SCI_NAMESPACE 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/CharClassify.cxx: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file CharClassify.cxx 3 | ** Character classifications used by Document and RESearch. 4 | **/ 5 | // Copyright 2006 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 | 13 | #include "CharClassify.h" 14 | 15 | #ifdef SCI_NAMESPACE 16 | using namespace Scintilla; 17 | #endif 18 | 19 | CharClassify::CharClassify() { 20 | SetDefaultCharClasses(true); 21 | } 22 | 23 | void CharClassify::SetDefaultCharClasses(bool includeWordClass) { 24 | // Initialize all char classes to default values 25 | for (int ch = 0; ch < 256; ch++) { 26 | if (ch == '\r' || ch == '\n') 27 | charClass[ch] = ccNewLine; 28 | else if (ch < 0x20 || ch == ' ') 29 | charClass[ch] = ccSpace; 30 | else if (includeWordClass && (ch >= 0x80 || isalnum(ch) || ch == '_')) 31 | charClass[ch] = ccWord; 32 | else 33 | charClass[ch] = ccPunctuation; 34 | } 35 | } 36 | 37 | void CharClassify::SetCharClasses(const unsigned char *chars, cc newCharClass) { 38 | // Apply the newCharClass to the specifed chars 39 | if (chars) { 40 | while (*chars) { 41 | charClass[*chars] = static_cast(newCharClass); 42 | chars++; 43 | } 44 | } 45 | } 46 | 47 | int CharClassify::GetCharsOfClass(cc characterClass, unsigned char *buffer) { 48 | // Get characters belonging to the given char class; return the number 49 | // of characters (if the buffer is NULL, don't write to it). 50 | int count = 0; 51 | for (int ch = maxChar - 1; ch >= 0; --ch) { 52 | if (charClass[ch] == characterClass) { 53 | ++count; 54 | if (buffer) { 55 | *buffer = static_cast(ch); 56 | buffer++; 57 | } 58 | } 59 | } 60 | return count; 61 | } 62 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/CharClassify.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file CharClassify.h 3 | ** Character classifications used by Document and RESearch. 4 | **/ 5 | // Copyright 2006-2009 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef CHARCLASSIFY_H 9 | #define CHARCLASSIFY_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | class CharClassify { 16 | public: 17 | CharClassify(); 18 | 19 | enum cc { ccSpace, ccNewLine, ccWord, ccPunctuation }; 20 | void SetDefaultCharClasses(bool includeWordClass); 21 | void SetCharClasses(const unsigned char *chars, cc newCharClass); 22 | int GetCharsOfClass(cc charClass, unsigned char *buffer); 23 | cc GetClass(unsigned char ch) const { return static_cast(charClass[ch]);} 24 | bool IsWord(unsigned char ch) const { return static_cast(charClass[ch]) == ccWord;} 25 | 26 | private: 27 | enum { maxChar=256 }; 28 | unsigned char charClass[maxChar]; // not type cc to save space 29 | }; 30 | 31 | #ifdef SCI_NAMESPACE 32 | } 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/Decoration.h: -------------------------------------------------------------------------------- 1 | /** @file Decoration.h 2 | ** Visual elements added over text. 3 | **/ 4 | // Copyright 1998-2007 by Neil Hodgson 5 | // The License.txt file describes the conditions under which this software may be distributed. 6 | 7 | #ifndef DECORATION_H 8 | #define DECORATION_H 9 | 10 | #ifdef SCI_NAMESPACE 11 | namespace Scintilla { 12 | #endif 13 | 14 | class Decoration { 15 | public: 16 | Decoration *next; 17 | RunStyles rs; 18 | int indicator; 19 | 20 | explicit Decoration(int indicator_); 21 | ~Decoration(); 22 | 23 | bool Empty() const; 24 | }; 25 | 26 | class DecorationList { 27 | int currentIndicator; 28 | int currentValue; 29 | Decoration *current; 30 | int lengthDocument; 31 | Decoration *DecorationFromIndicator(int indicator); 32 | Decoration *Create(int indicator, int length); 33 | void Delete(int indicator); 34 | void DeleteAnyEmpty(); 35 | public: 36 | Decoration *root; 37 | bool clickNotified; 38 | 39 | DecorationList(); 40 | ~DecorationList(); 41 | 42 | void SetCurrentIndicator(int indicator); 43 | int GetCurrentIndicator() const { return currentIndicator; } 44 | 45 | void SetCurrentValue(int value); 46 | int GetCurrentValue() const { return currentValue; } 47 | 48 | // Returns true if some values may have changed 49 | bool FillRange(int &position, int value, int &fillLength); 50 | 51 | void InsertSpace(int position, int insertLength); 52 | void DeleteRange(int position, int deleteLength); 53 | 54 | int AllOnFor(int position) const; 55 | int ValueAt(int indicator, int position); 56 | int Start(int indicator, int position); 57 | int End(int indicator, int position); 58 | }; 59 | 60 | #ifdef SCI_NAMESPACE 61 | } 62 | #endif 63 | 64 | #endif 65 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/EditModel.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file EditModel.h 3 | ** Defines the editor state that must be visible to EditorView. 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 EDITMODEL_H 9 | #define EDITMODEL_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | /** 16 | */ 17 | class Caret { 18 | public: 19 | bool active; 20 | bool on; 21 | int period; 22 | 23 | Caret(); 24 | }; 25 | 26 | class EditModel { 27 | // Private so EditModel objects can not be copied 28 | explicit EditModel(const EditModel &); 29 | EditModel &operator=(const EditModel &); 30 | 31 | public: 32 | bool inOverstrike; 33 | int xOffset; ///< Horizontal scrolled amount in pixels 34 | bool trackLineWidth; 35 | 36 | SpecialRepresentations reprs; 37 | Caret caret; 38 | SelectionPosition posDrag; 39 | Position braces[2]; 40 | int bracesMatchStyle; 41 | int highlightGuideColumn; 42 | Selection sel; 43 | bool primarySelection; 44 | 45 | enum IMEInteraction { imeWindowed, imeInline } imeInteraction; 46 | 47 | int foldFlags; 48 | ContractionState cs; 49 | // Hotspot support 50 | Range hotspot; 51 | int hoverIndicatorPos; 52 | 53 | // Wrapping support 54 | int wrapWidth; 55 | 56 | Document *pdoc; 57 | 58 | EditModel(); 59 | virtual ~EditModel(); 60 | virtual int TopLineOfMain() const = 0; 61 | virtual Point GetVisibleOriginInMain() const = 0; 62 | virtual int LinesOnScreen() const = 0; 63 | virtual Range GetHotSpotRange() const = 0; 64 | }; 65 | 66 | #ifdef SCI_NAMESPACE 67 | } 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/FontQuality.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file FontQuality.h 3 | ** Definitions to control font anti-aliasing. 4 | ** Redefine constants from Scintilla.h to avoid including Scintilla.h in PlatWin.cxx. 5 | **/ 6 | // Copyright 1998-2009 by Neil Hodgson 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | #ifndef FONTQUALITY_H 10 | #define FONTQUALITY_H 11 | 12 | #ifdef SCI_NAMESPACE 13 | namespace Scintilla { 14 | #endif 15 | 16 | // These definitions match Scintilla.h 17 | #define SC_EFF_QUALITY_MASK 0xF 18 | #define SC_EFF_QUALITY_DEFAULT 0 19 | #define SC_EFF_QUALITY_NON_ANTIALIASED 1 20 | #define SC_EFF_QUALITY_ANTIALIASED 2 21 | #define SC_EFF_QUALITY_LCD_OPTIMIZED 3 22 | 23 | // These definitions must match SC_TECHNOLOGY_* in Scintilla.h 24 | #define SCWIN_TECH_GDI 0 25 | #define SCWIN_TECH_DIRECTWRITE 1 26 | 27 | #ifdef SCI_NAMESPACE 28 | } 29 | #endif 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/KeyMap.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file KeyMap.h 3 | ** Defines a mapping between keystrokes and commands. 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 KEYMAP_H 9 | #define KEYMAP_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | #define SCI_NORM 0 16 | #define SCI_SHIFT SCMOD_SHIFT 17 | #define SCI_CTRL SCMOD_CTRL 18 | #define SCI_ALT SCMOD_ALT 19 | #define SCI_META SCMOD_META 20 | #define SCI_SUPER SCMOD_SUPER 21 | #define SCI_CSHIFT (SCI_CTRL | SCI_SHIFT) 22 | #define SCI_ASHIFT (SCI_ALT | SCI_SHIFT) 23 | 24 | /** 25 | */ 26 | class KeyModifiers { 27 | public: 28 | int key; 29 | int modifiers; 30 | KeyModifiers(int key_, int modifiers_) : key(key_), modifiers(modifiers_) { 31 | } 32 | bool operator<(const KeyModifiers &other) const { 33 | if (key == other.key) 34 | return modifiers < other.modifiers; 35 | else 36 | return key < other.key; 37 | } 38 | }; 39 | 40 | /** 41 | */ 42 | class KeyToCommand { 43 | public: 44 | int key; 45 | int modifiers; 46 | unsigned int msg; 47 | }; 48 | 49 | /** 50 | */ 51 | class KeyMap { 52 | std::map kmap; 53 | static const KeyToCommand MapDefault[]; 54 | 55 | public: 56 | KeyMap(); 57 | ~KeyMap(); 58 | void Clear(); 59 | void AssignCmdKey(int key, int modifiers, unsigned int msg); 60 | unsigned int Find(int key, int modifiers) const; // 0 returned on failure 61 | }; 62 | 63 | #ifdef SCI_NAMESPACE 64 | } 65 | #endif 66 | 67 | #endif 68 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/MarginView.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file MarginView.h 3 | ** Defines the appearance of the editor margin. 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 MARGINVIEW_H 9 | #define MARGINVIEW_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour); 16 | 17 | typedef void (*DrawWrapMarkerFn)(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour); 18 | 19 | /** 20 | * MarginView draws the margins. 21 | */ 22 | class MarginView { 23 | public: 24 | Surface *pixmapSelMargin; 25 | Surface *pixmapSelPattern; 26 | Surface *pixmapSelPatternOffset1; 27 | // Highlight current folding block 28 | HighlightDelimiter highlightDelimiter; 29 | 30 | int wrapMarkerPaddingRight; // right-most pixel padding of wrap markers 31 | /** Some platforms, notably PLAT_CURSES, do not support Scintilla's native 32 | * DrawWrapMarker function for drawing wrap markers. Allow those platforms to 33 | * override it instead of creating a new method in the Surface class that 34 | * existing platforms must implement as empty. */ 35 | DrawWrapMarkerFn customDrawWrapMarker; 36 | 37 | MarginView(); 38 | 39 | void DropGraphics(bool freeObjects); 40 | void AllocateGraphics(const ViewStyle &vsDraw); 41 | void RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw); 42 | void PaintMargin(Surface *surface, int topLine, PRectangle rc, PRectangle rcMargin, 43 | const EditModel &model, const ViewStyle &vs); 44 | }; 45 | 46 | #ifdef SCI_NAMESPACE 47 | } 48 | #endif 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/Position.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file Position.h 3 | ** Defines global type name Position in the Sci internal namespace. 4 | **/ 5 | // Copyright 2015 by Neil Hodgson 6 | // The License.txt file describes the conditions under which this software may be distributed. 7 | 8 | #ifndef POSITION_H 9 | #define POSITION_H 10 | 11 | /** 12 | * A Position is a position within a document between two characters or at the beginning or end. 13 | * Sometimes used as a character index where it identifies the character after the position. 14 | */ 15 | 16 | namespace Sci { 17 | 18 | typedef int Position; 19 | 20 | // A later version (4.x) of this file may: 21 | //#if defined(SCI_LARGE_FILE_SUPPORT) 22 | //typedef std::ptrdiff_t Position; 23 | // or may allow runtime choice between different position sizes. 24 | 25 | const Position invalidPosition = -1; 26 | 27 | } 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/RunStyles.h: -------------------------------------------------------------------------------- 1 | /** @file RunStyles.h 2 | ** Data structure used to store sparse styles. 3 | **/ 4 | // Copyright 1998-2007 by Neil Hodgson 5 | // The License.txt file describes the conditions under which this software may be distributed. 6 | 7 | /// Styling buffer using one element for each run rather than using 8 | /// a filled buffer. 9 | 10 | #ifndef RUNSTYLES_H 11 | #define RUNSTYLES_H 12 | 13 | #ifdef SCI_NAMESPACE 14 | namespace Scintilla { 15 | #endif 16 | 17 | class RunStyles { 18 | private: 19 | Partitioning *starts; 20 | SplitVector *styles; 21 | int RunFromPosition(int position) const; 22 | int SplitRun(int position); 23 | void RemoveRun(int run); 24 | void RemoveRunIfEmpty(int run); 25 | void RemoveRunIfSameAsPrevious(int run); 26 | // Private so RunStyles objects can not be copied 27 | RunStyles(const RunStyles &); 28 | public: 29 | RunStyles(); 30 | ~RunStyles(); 31 | int Length() const; 32 | int ValueAt(int position) const; 33 | int FindNextChange(int position, int end) const; 34 | int StartRun(int position) const; 35 | int EndRun(int position) const; 36 | // Returns true if some values may have changed 37 | bool FillRange(int &position, int value, int &fillLength); 38 | void SetValueAt(int position, int value); 39 | void InsertSpace(int position, int insertLength); 40 | void DeleteAll(); 41 | void DeleteRange(int position, int deleteLength); 42 | int Runs() const; 43 | bool AllSame() const; 44 | bool AllSameAs(int value) const; 45 | int Find(int value, int start) const; 46 | 47 | void Check() const; 48 | }; 49 | 50 | #ifdef SCI_NAMESPACE 51 | } 52 | #endif 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/SciTE.properties: -------------------------------------------------------------------------------- 1 | # SciTE.properties is the per directory local options file and can be used to override 2 | # settings made in SciTEGlobal.properties 3 | command.build.directory.*.cxx=..\win32 4 | command.build.directory.*.h=..\win32 5 | command.build.*.cxx=nmake -f scintilla.mak QUIET=1 6 | command.build.*.h=nmake -f scintilla.mak QUIET=1 7 | -------------------------------------------------------------------------------- /src/scite/scintilla/src/UnicodeFromUTF8.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file UnicodeFromUTF8.h 3 | ** Lexer infrastructure. 4 | **/ 5 | // Copyright 2013 by Neil Hodgson 6 | // This file is in the public domain. 7 | 8 | #ifndef UNICODEFROMUTF8_H 9 | #define UNICODEFROMUTF8_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | inline int UnicodeFromUTF8(const unsigned char *us) { 16 | if (us[0] < 0xC2) { 17 | return us[0]; 18 | } else if (us[0] < 0xE0) { 19 | return ((us[0] & 0x1F) << 6) + (us[1] & 0x3F); 20 | } else if (us[0] < 0xF0) { 21 | return ((us[0] & 0xF) << 12) + ((us[1] & 0x3F) << 6) + (us[2] & 0x3F); 22 | } else if (us[0] < 0xF5) { 23 | return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F); 24 | } 25 | return us[0]; 26 | } 27 | 28 | #ifdef SCI_NAMESPACE 29 | } 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/scite/scintilla/version.txt: -------------------------------------------------------------------------------- 1 | 366 2 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/CheckD2D.cxx: -------------------------------------------------------------------------------- 1 | // This file is compiled to check whether Direct2D and DirectWrite headers are available. 2 | #include 3 | #include 4 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/HanjaDic.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file HanjaDic.h 3 | ** Korean Hanja Dictionary 4 | ** Convert between Korean Hanja and Hangul by COM interface. 5 | **/ 6 | // Copyright 2015 by Neil Hodgson 7 | // The License.txt file describes the conditions under which this software may be distributed. 8 | 9 | #ifndef HANJADIC_H 10 | #define HANJADIC_H 11 | 12 | #ifdef SCI_NAMESPACE 13 | namespace Scintilla { 14 | #endif 15 | 16 | namespace HanjaDict { 17 | 18 | int GetHangulOfHanja(wchar_t *inout); 19 | 20 | } 21 | 22 | #ifdef SCI_NAMESPACE 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/PlatWin.h: -------------------------------------------------------------------------------- 1 | // Scintilla source code edit control 2 | /** @file PlatWin.h 3 | ** Implementation of platform facilities on Windows. 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 PLATWIN_H 9 | #define PLATWIN_H 10 | 11 | #ifdef SCI_NAMESPACE 12 | namespace Scintilla { 13 | #endif 14 | 15 | extern void Platform_Initialise(void *hInstance); 16 | extern void Platform_Finalise(bool fromDllMain); 17 | 18 | #if defined(USE_D2D) 19 | extern bool LoadD2D(); 20 | extern ID2D1Factory *pD2DFactory; 21 | extern IDWriteFactory *pIDWriteFactory; 22 | #endif 23 | 24 | #ifdef SCI_NAMESPACE 25 | } 26 | #endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/SciTE.properties: -------------------------------------------------------------------------------- 1 | command.build.SConstruct=scons.bat . 2 | command.name.1.SConstruct=scons clean 3 | command.1.SConstruct=scons.bat --clean . 4 | 5 | command.build.*.mak=nmake -f $(FileNameExt) DEBUG=1 QUIET=1 6 | command.name.1.*.mak=nmake clean 7 | command.1.*.mak=nmake -f $(FileNameExt) clean 8 | command.name.2.*.mak=Borland Make 9 | command.2.*.mak=make -f $(FileNameExt) 10 | command.subsystem.2.*.mak=0 11 | command.name.3.*.mak=make clean 12 | command.3.*.mak=make -f $(FileNameExt) clean 13 | command.name.4.*.mak=make debug 14 | command.4.*.mak=make DEBUG=1 -f $(FileNameExt) 15 | command.name.5.*.mak=nmake debug 16 | command.5.*.mak=nmake DEBUG=1 -f $(FileNameExt) 17 | # SciTE.properties is the per directory local options file and can be used to override 18 | # settings made in SciTEGlobal.properties 19 | command.build.*.cxx=nmake -f scintilla.mak DEBUG=1 QUIET=1 20 | command.build.*.h=nmake -f scintilla.mak DEBUG=1 QUIET=1 21 | command.build.*.rc=nmake -f scintilla.mak DEBUG=1 QUIET=1 22 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/ScintRes.rc: -------------------------------------------------------------------------------- 1 | // Resource file for Scintilla 2 | // Copyright 1998-2010 by Neil Hodgson 3 | // The License.txt file describes the conditions under which this software may be distributed. 4 | 5 | #include 6 | 7 | #define VERSION_SCINTILLA "3.6.6" 8 | #define VERSION_WORDS 3, 6, 6, 0 9 | 10 | VS_VERSION_INFO VERSIONINFO 11 | FILEVERSION VERSION_WORDS 12 | PRODUCTVERSION VERSION_WORDS 13 | FILEFLAGSMASK 0x3fL 14 | FILEFLAGS 0 15 | FILEOS VOS_NT_WINDOWS32 16 | FILETYPE VFT_APP 17 | FILESUBTYPE VFT2_UNKNOWN 18 | BEGIN 19 | BLOCK "VarFileInfo" 20 | BEGIN 21 | VALUE "Translation", 0x409, 1200 22 | END 23 | BLOCK "StringFileInfo" 24 | BEGIN 25 | BLOCK "040904b0" 26 | BEGIN 27 | VALUE "CompanyName", "Neil Hodgson neilh@scintilla.org\0" 28 | VALUE "FileDescription", "Scintilla.DLL - a Source Editing Component\0" 29 | VALUE "FileVersion", VERSION_SCINTILLA "\0" 30 | VALUE "InternalName", "Scintilla\0" 31 | VALUE "LegalCopyright", "Copyright 1998-2012 by Neil Hodgson\0" 32 | VALUE "OriginalFilename", "Scintilla.DLL\0" 33 | VALUE "ProductName", "Scintilla\0" 34 | VALUE "ProductVersion", VERSION_SCINTILLA "\0" 35 | END 36 | END 37 | END 38 | -------------------------------------------------------------------------------- /src/scite/scintilla/win32/Scintilla.def: -------------------------------------------------------------------------------- 1 | EXPORTS 2 | Scintilla_DirectFunction -------------------------------------------------------------------------------- /src/scite/scite/bin/doc/Documentation.txt: -------------------------------------------------------------------------------- 1 | 2 | SciTE-with-Python 3 | By Ben Fisher, 2016 4 | 5 | The documentation for this project can be found online at 6 | https://github.com/moltenform/scite-with-python 7 | -------------------------------------------------------------------------------- /src/scite/scite/bin/properties/disabled/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 | lexer.$(file.patterns.gap)=gap 11 | 12 | *language.gap=Gap|g|| 13 | 14 | keywords.$(file.patterns.gap)=and break continue do elif else end fi for function \ 15 | if in local mod not od or quit rec repeat return then until while QUIT 16 | 17 | keywords2.$(file.patterns.gap)=false true IsBound Unbind TryNextMethod \ 18 | Info Assert SaveWorkspace fail 19 | 20 | #keywords3.$(file.patterns.gap) 21 | 22 | comment.block.gap=#~ 23 | 24 | # GAP styles 25 | # White space 26 | style.gap.0=fore:#808080 27 | # Identifiers 28 | style.gap.1= 29 | # Keywords 30 | style.gap.2=$(colour.keyword),bold 31 | # Keywords 2 32 | style.gap.3=$(colour.keyword) 33 | # Keywords 3 34 | style.gap.4=$(colour.keyword) 35 | # Keywords 4 36 | style.gap.5=$(colour.keyword) 37 | # Strings 38 | style.gap.6=$(colour.string) 39 | # Characters 40 | style.gap.7=$(colour.char) 41 | # Operators 42 | style.gap.8=$(colour.operator),bold 43 | # Comment 44 | style.gap.9=$(colour.code.comment.line) 45 | # Numbers 46 | style.gap.10=$(colour.number) 47 | # End of line where string is not closed 48 | style.gap.11=fore:#000000,$(font.monospace),back:#E0C0E0,eolfilled 49 | 50 | # Braces are only matched in operator style 51 | braces.gap.style=8 -------------------------------------------------------------------------------- /src/scite/scite/bin/properties/disabled/json.properties: -------------------------------------------------------------------------------- 1 | # Define SciTE settings for JSON files. 2 | 3 | file.patterns.json=*.json;*.eslintrc;*.jshintrc;*.jsonld 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/scite/scite/bin/properties/disabled/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.9.*.tex=View PS 46 | command.9.*.tex=gv $(FileName).ps 47 | -------------------------------------------------------------------------------- /src/scite/scite/bin/properties/disabled/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/scite/scite/bin/properties/disabled/rebol.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/bin/properties/disabled/rebol.properties -------------------------------------------------------------------------------- /src/scite/scite/bin/properties/disabled/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/scite/scite/bin/properties/disabled/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/scite/scite/bin/properties/disabled/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/scite/scite/bin/properties/disabled/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/scite/scite/bin/properties/html.properties: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/bin/properties/html.properties -------------------------------------------------------------------------------- /src/scite/scite/bin/python27.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/bin/python27.zip -------------------------------------------------------------------------------- /src/scite/scite/bin/pythonbinaries.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/bin/pythonbinaries.zip -------------------------------------------------------------------------------- /src/scite/scite/bin/setup.cfg: -------------------------------------------------------------------------------- 1 | 2 | [flake8] 3 | max-line-length = 150 4 | ignore = F403, E302, W293, E128, E228, E401, W191, E261, E402, F405, W391 5 | 6 | # W191: tabs to indent 7 | # E261: at least two spaces before inline comment 8 | # E402: module level import not at top of file 9 | # F405: doesn't like star imports 10 | # W391: whitespace at end of file 11 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_external/tools_change_encoding/change_encoding.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | import os 6 | import sys 7 | import codecs 8 | 9 | def getRawInput(prompt): 10 | print(prompt) 11 | sys.stdout.flush() 12 | if sys.version_info[0] <= 2: 13 | return raw_input('') 14 | else: 15 | return input('') 16 | 17 | def askForCodec(prompt, defaultCodec): 18 | while True: 19 | scodec = getRawInput('\n' + prompt).strip() 20 | if scodec == 'q': 21 | return None 22 | 23 | try: 24 | scodec = scodec or defaultCodec 25 | codecs.lookup(scodec) 26 | return scodec 27 | except LookupError: 28 | print('Could not find this codec (' + scodec + ')') 29 | 30 | def go(path): 31 | print('Change encoding.\nChanges the current file,\nit might make sense to keep a backup copy.') 32 | source = askForCodec('Please type the current encoding and press Enter \n(default=cp1252, q to exit):', 'cp1252') 33 | if source is None: 34 | return 35 | 36 | dest = askForCodec('Please type the destination encoding and press Enter \n(default=utf-8, q to exit):', 'utf-8') 37 | if dest is None: 38 | return 39 | 40 | with codecs.open(path, 'rb', source) as fin: 41 | alltxt = fin.read() 42 | 43 | with codecs.open(path, 'wb', dest) as fout: 44 | fout.write(alltxt) 45 | 46 | if __name__ == '__main__': 47 | if len(sys.argv) > 1 and os.path.isfile(sys.argv[1]): 48 | go(sys.argv[1]) 49 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_external/tools_change_encoding/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.change_encoding=change_encoding| 4 | customcommand.change_encoding.name=Change encoding... 5 | customcommand.change_encoding.shortcut=Ctrl+Alt+Shift+E 6 | customcommand.change_encoding.action.waitforcomplete=$(customcommand.externalpython) "$(SciteDefaultHome)/tools_external/tools_change_encoding/change_encoding.py" "$(FilePath)" 7 | customcommand.change_encoding.mode=savebefore:prompt;filter:yes 8 | 9 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_external/tools_example_ext/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # reference: 5 | # set an action by setting one of the following: 6 | # customcommand.cmdname.action.py= 7 | # customcommand.cmdname.action.start= 8 | # customcommand.cmdname.action.waitforcomplete= 9 | # customcommand.cmdname.action.waitforcomplete_console= 10 | # 11 | # 12 | # Can use an action starting with * to show a params dialog 13 | # 14 | # 15 | # Additional options can be set with customcommand.cmdname.mode= 16 | # filter (yes/no) (indicates current file will be modified) 17 | # quiet (yes/no) (suppresses stdout) 18 | # replaceselection (yes/no/auto) 19 | # savebefore (yes/no/prompt) 20 | # 21 | # 22 | # If using waitforcomplete_console, can provide a string to stdin 23 | # customcommand.cmdname.action.stdin=testing string 24 | 25 | *customcommandsregister.example_openpaint=example_openpaint| 26 | customcommand.example_openpaint.name=Open paint 27 | customcommand.example_openpaint.filetypes=*.png 28 | customcommand.example_openpaint.shortcut=Ctrl+Alt+Shift+5 29 | customcommand.example_openpaint.action.start=c:\windows\System32\mspaint.exe "$(FilePath)" 30 | 31 | *customcommandsregister.example_runpython=example_runpython| 32 | customcommand.example_runpython.name=Run external python 33 | customcommand.example_runpython.shortcut=Ctrl+Alt+Shift+6 34 | customcommand.example_runpython.action.waitforcomplete_console=$(customcommand.externalpython) -c "print 'extpython'" 35 | 36 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_external/tools_py_error_context/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | def WritePrintStatement(word): 6 | from scite_extend_ui import ScEditor 7 | whatToWrite = "print('''%s = ''' + str(%s))"%(word, word) 8 | 9 | ScEditor.BeginUndoAction() 10 | try: 11 | ScEditor.LineEnd() 12 | ScEditor.NewLine() 13 | ScEditor.PaneWrite(whatToWrite) 14 | finally: 15 | ScEditor.EndUndoAction() 16 | 17 | def AddPrintStatement(): 18 | from scite_extend_ui import ScApp, ScEditor 19 | if ScEditor.GetFocus() and ScEditor.GetSelections() <= 1: 20 | sel = ScEditor.GetSelectedText() 21 | if sel and sel.strip(): 22 | if '\n' in sel or '\r' in sel: 23 | print('Select within one line.') 24 | else: 25 | WritePrintStatement(sel) 26 | else: 27 | word = ScApp.GetProperty('CurrentWord') 28 | if word and word.strip(): 29 | WritePrintStatement(word) 30 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_external/tools_py_error_context/register.properties: -------------------------------------------------------------------------------- 1 | 2 | command.compile.$(file.patterns.py)=$(customcommand.externalpython) "$(SciteDefaultHome)/tools_external/tools_py_error_context/py_error_context.py" "$(FilePath)" 3 | command.compile.needs.$(file.patterns.py)= 4 | command.compile.subsystem.$(file.patterns.py)= 5 | 6 | *customcommandsregister.print_current_variable=print_current_variable| 7 | customcommand.print_current_variable.name=Print current variable 8 | customcommand.print_current_variable.shortcut=Ctrl+Shift+Y 9 | customcommand.print_current_variable.action.py=ThisModule().AddPrintStatement() 10 | customcommand.print_current_variable.path=tools_external/tools_py_error_context 11 | customcommand.print_current_variable.filetypes=$(file.patterns.py) 12 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/ben_python_common/__init__.py: -------------------------------------------------------------------------------- 1 | # BenPythonCommon, 2 | # 2015 Ben Fisher, released under the LGPLv3 license. 3 | 4 | from .common_ui import * # noqa: F401 5 | from . import files # noqa: F401 6 | from . import common_jslike as jslike # noqa: F401 7 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/ben_python_common/printclipboard.py: -------------------------------------------------------------------------------- 1 | # BenPythonCommon, 2 | # 2015 Ben Fisher, released under the LGPLv3 license. 3 | 4 | import pyperclip 5 | txt = pyperclip.paste() 6 | txt = unicode(txt).encode('utf-8') 7 | print(txt) 8 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/ben_python_common/pyperclip/PKG-INFO: -------------------------------------------------------------------------------- 1 | Metadata-Version: 1.1 2 | Name: pyperclip 3 | Version: 1.5.27 4 | Summary: A cross-platform clipboard module for Python. (only handles plain text for now) 5 | Home-page: https://github.com/asweigart/pyperclip 6 | Author: Al Sweigart 7 | Author-email: al@inventwithpython.com 8 | License: BSD 9 | Description: UNKNOWN 10 | Keywords: gui automation test testing keyboard mouse cursor click press keystroke control 11 | Platform: UNKNOWN 12 | Classifier: Development Status :: 5 - Production/Stable 13 | Classifier: Environment :: Win32 (MS Windows) 14 | Classifier: Environment :: X11 Applications 15 | Classifier: Environment :: MacOS X 16 | Classifier: Intended Audience :: Developers 17 | Classifier: License :: OSI Approved :: BSD License 18 | Classifier: Operating System :: OS Independent 19 | Classifier: Programming Language :: Python 20 | Classifier: Programming Language :: Python :: 2 21 | Classifier: Programming Language :: Python :: 2.6 22 | Classifier: Programming Language :: Python :: 2.7 23 | Classifier: Programming Language :: Python :: 3 24 | Classifier: Programming Language :: Python :: 3.1 25 | Classifier: Programming Language :: Python :: 3.2 26 | Classifier: Programming Language :: Python :: 3.3 27 | Classifier: Programming Language :: Python :: 3.4 28 | Classifier: Programming Language :: Python :: 3.5 29 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/ben_python_common/pyperclip/exceptions.py: -------------------------------------------------------------------------------- 1 | import ctypes 2 | 3 | 4 | class PyperclipException(RuntimeError): 5 | pass 6 | 7 | 8 | class PyperclipWindowsException(PyperclipException): 9 | def __init__(self, message): 10 | message += " (%s)" % ctypes.WinError() 11 | super(PyperclipWindowsException, self).__init__(message) 12 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/ben_python_common/setup.cfg: -------------------------------------------------------------------------------- 1 | 2 | [flake8] 3 | max-line-length = 140 4 | ignore = F403, F405, E302, E402, E128, E228, E401, E722, E731, W504, E251 5 | # F403 'from module import *' used; unable to detect undefined names 6 | # F405 Name may be undefined, or defined from star imports: module 7 | # E302 Expected 2 blank lines, found 0 8 | # E402 Module level import not at top of file 9 | # E128 Continuation line under-indented for visual indent 10 | # E228 Missing whitespace around modulo operator 11 | # E401 Multiple imports on one line 12 | # E722 Do not use bare 'except' 13 | # E731 Do not assign a lambda expression, use a def 14 | # W504 Line break occurred after a binary operator 15 | # E251 Unexpected spaces around keyword / parameter equals 16 | 17 | # these might also be useful to disable 18 | # F405 ok to use a symbol from a import * 19 | # W293 Blank line contains whitespace 20 | # W391 Blank line at end of file 21 | 22 | # for python 2 compat, tell flake8 that these names are valid 23 | builtins = 24 | raw_input, 25 | unicode, 26 | basestring, 27 | unichr, 28 | xrange 29 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_auto_type_xml/register.properties: -------------------------------------------------------------------------------- 1 | 2 | # when editing xml, typing > will automatically close the tag. 3 | 4 | *customcommandsregister.auto_type_xml=auto_type_xml| 5 | customcommand.auto_type_xml.name=Autotype xml 6 | customcommand.auto_type_xml.path=tools_internal/tools_auto_type_xml 7 | customcommand.auto_type_xml.callbacks=OnChar 8 | 9 | 10 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_current_directory/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | from scite_extend_ui import * 6 | 7 | def CopyCurrentDirectory(): 8 | dir = ScApp.GetFileDirectory() 9 | ScEditor.Utils.SetClipboardText(dir) 10 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_current_directory/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | *customcommandsregister.copy_current_directory=copy_current_directory| 6 | customcommand.copy_current_directory.name=Copy current folder 7 | customcommand.copy_current_directory.shortcut=Ctrl+1 8 | customcommand.copy_current_directory.action.py_immediate=ThisModule().CopyCurrentDirectory() 9 | customcommand.copy_current_directory.path=tools_internal/tools_current_directory 10 | 11 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_disable_directory/register.properties: -------------------------------------------------------------------------------- 1 | 2 | # sometimes you might want to remind yourself that certain files shouldn't be edited lightly. 3 | # set customcommand.disable_directory.disabled_directories below. 4 | # when SciTE edits any files in these directories the background will be RED, 5 | # a good reminder to think twice :) 6 | 7 | *customcommandsregister.disable_directory=disable_directory| 8 | customcommand.disable_directory.name=Disable directory 9 | customcommand.disable_directory.path=tools_internal/tools_disable_directory 10 | customcommand.disable_directory.callbacks=OnKey|OnFileChange|OnClose 11 | 12 | customcommand.disable_directory.disabled_directories=\ 13 | |c:\example\important_files_not_to_edit\ 14 | |c:\example\other_important_files_not_to_edit\ 15 | 16 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_example_int/ExampleSubmodule.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | from scite_extend_ui import ScConst, ScToolUIBase 6 | 7 | class ExampleUI(ScToolUIBase): 8 | def AddControls(self): 9 | self.AddLabel('Explanation') 10 | self.cmb = self.AddCombo() 11 | self.btnGo = self.AddButton('Go', callback=self.OnGo) 12 | self.AddRow() 13 | self.AddLabel('Name:') 14 | self.entry = self.AddEntry('default name') 15 | self.AddButton('OK', callback=self.OnOK, default=True, closes=True) 16 | self.AddButton('Cancel', closes=True) 17 | 18 | def OnOpen(self): 19 | self.Set(self.entry, 'different default name') 20 | self.SetList(self.cmb, 'banana\nlemon\norange') 21 | 22 | def OnGo(self): 23 | print('clicked Go with value %s and %s'%(self.Get(self.cmb), self.Get(self.entry))) 24 | 25 | def OnOK(self): 26 | print('clicked OK with value %s and %s'%(self.Get(self.cmb), self.Get(self.entry))) 27 | 28 | def OnEvent(self, control, eventType): 29 | # we wouldn't usually need this method, but just a demo 30 | if control == self.entry and eventType == ScConst.eventTypeChange: 31 | print('entry changed') 32 | 33 | def OnKey(key, shift, ctrl, alt): 34 | # stop the ctrl-w shortcut 35 | if key == ord('W') and not shift and ctrl and not alt: 36 | print('swallowed') 37 | return ScConst.StopEventPropagation 38 | 39 | # have ctrl-alt-shift-w open an example tool ui 40 | if key == ord('W') and shift and ctrl and alt: 41 | print('opening tool ui') 42 | toolui = ExampleUI() 43 | toolui.Show() 44 | 45 | def CallSubmodule(): 46 | print('Called submodule.') 47 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_example_int/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | debugTracing = False 6 | 7 | def OnOpen(filename): 8 | if debugTracing: 9 | print('plugin saw OnOpen', filename) 10 | 11 | def OnFileChange(): 12 | if debugTracing: 13 | print('plugin saw OnFileChange') 14 | 15 | def OnClose(filename): 16 | if debugTracing: 17 | print('plugin saw OnClose' + filename) 18 | 19 | def CallSubmodule(): 20 | import ExampleSubmodule 21 | ExampleSubmodule.CallSubmodule() 22 | 23 | def OnKey(*args): 24 | import ExampleSubmodule 25 | return ExampleSubmodule.OnKey(*args) 26 | 27 | def OnUserStrip(*args): 28 | import ExampleSubmodule 29 | return ExampleSubmodule.OnUserStrip(*args) 30 | 31 | print('Loading the module. Expect to see this message only once.') 32 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_example_int/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.example_inserttext=example_inserttext| 4 | customcommand.example_inserttext.name=Example Insert text 5 | customcommand.example_inserttext.shortcut=Ctrl+Alt+Shift+7 6 | customcommand.example_inserttext.action.py=from scite_extend_ui import ScEditor; ScEditor.PaneWrite(r'inserted $(FilePath) ') 7 | 8 | *customcommandsregister.example_call_submodule=example_call_submodule| 9 | customcommand.example_call_submodule.name=Example Call Submodule 10 | customcommand.example_call_submodule.shortcut=Ctrl+Alt+Shift+8 11 | customcommand.example_call_submodule.action.py=ThisModule().CallSubmodule() 12 | customcommand.example_call_submodule.callbacks=OnOpen|OnFileChange|OnClose|OnKey 13 | customcommand.example_call_submodule.path=tools_internal/tools_example_int 14 | 15 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_insert_accented_character/register.properties: -------------------------------------------------------------------------------- 1 | 2 | *customcommandsregister.insert_accented_character=insert_accented_character| 3 | customcommand.insert_accented_character.name=Insert accented character... 4 | customcommand.insert_accented_character.shortcut=Ctrl+' 5 | customcommand.insert_accented_character.action.py=ThisModule().DoInsertAccentedCharacter() 6 | customcommand.insert_accented_character.path=tools_internal/tools_insert_accented_character 7 | 8 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_insert_text/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # SciTE Python Extension 3 | # Ben Fisher, 2016 4 | # Released under the GNU General Public License version 3 5 | 6 | def InsertSectionBreakText(): 7 | from scite_extend_ui import ScEditor 8 | block = u'▃' 9 | amount = 32 10 | whatToWrite = u'' 11 | whatToWrite += u'# ' + block * int(amount // 2) 12 | whatToWrite += ' ' 13 | whatToWrite += block * int(amount // 2) 14 | whatToWriteBytes = whatToWrite.encode('utf-8') 15 | 16 | ScEditor.BeginUndoAction() 17 | try: 18 | ScEditor.PaneWrite(whatToWriteBytes) 19 | for _ in range(1 + int(amount // 2)): 20 | ScEditor.CharLeft() 21 | finally: 22 | ScEditor.EndUndoAction() 23 | 24 | 25 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_insert_text/register.properties: -------------------------------------------------------------------------------- 1 | 2 | # need to use this indirection so that 3 | # the \ isn't mistakenly escaping the following newline 4 | insert_section_break_text_backslash_char=\\ 5 | 6 | 7 | *customcommandsregister.insert_section_break_text=insert_section_break_text| 8 | customcommand.insert_section_break_text.name=Insert text for new section 9 | customcommand.insert_section_break_text.shortcut=Ctrl+Shift+$(insert_section_break_text_backslash_char) 10 | customcommand.insert_section_break_text.action.py=ThisModule().InsertSectionBreakText() 11 | customcommand.insert_section_break_text.path=tools_internal/tools_insert_text 12 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_line_copy_if_no_selection/register.properties: -------------------------------------------------------------------------------- 1 | 2 | # specify py_immediate; this action should run even if another action is in progress. 3 | 4 | *customcommandsregister.line_copy_if_no_selection=line_copy_if_no_selection| 5 | customcommand.line_copy_if_no_selection.name=Line copy if no selection 6 | customcommand.line_copy_if_no_selection.shortcut=Ctrl+C 7 | customcommand.line_copy_if_no_selection.action.py_immediate=ThisModule().DoLineCopyIfNoSelection() 8 | customcommand.line_copy_if_no_selection.path=tools_internal/tools_line_copy_if_no_selection 9 | 10 | *customcommandsregister.line_cut_if_no_selection=line_cut_if_no_selection| 11 | customcommand.line_cut_if_no_selection.name=Line cut if no selection 12 | customcommand.line_cut_if_no_selection.shortcut=Ctrl+X 13 | customcommand.line_cut_if_no_selection.action.py_immediate=ThisModule().DoLineCutIfNoSelection() 14 | customcommand.line_cut_if_no_selection.path=tools_internal/tools_line_copy_if_no_selection 15 | 16 | *customcommandsregister.line_paste_if_has_line=line_paste_if_has_line| 17 | customcommand.line_paste_if_has_line.name=Line paste if clipboard has entire line 18 | customcommand.line_paste_if_has_line.shortcut=Ctrl+V 19 | customcommand.line_paste_if_has_line.action.py_immediate=ThisModule().DoLinePasteIfHasLine() 20 | customcommand.line_paste_if_has_line.path=tools_internal/tools_line_copy_if_no_selection 21 | 22 | *customcommandsregister.line_duplicate_entire_line=line_duplicate_entire_line| 23 | customcommand.line_duplicate_entire_line.name=Duplicate line 24 | customcommand.line_duplicate_entire_line.shortcut=Ctrl+D 25 | customcommand.line_duplicate_entire_line.action.py_immediate=ThisModule().DoLineDuplicateEntireLine() 26 | customcommand.line_duplicate_entire_line.path=tools_internal/tools_line_copy_if_no_selection 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_location/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | from scite_extend_ui import ScApp, ScEditor, ScConst 6 | import os 7 | 8 | # ctrl-shift-j to move to start/end of block 9 | from goblocklocation import * 10 | 11 | # ctrl-shift-o to open selected text 12 | from openselectedtext import * 13 | 14 | # ctrl-shift-t to re-open closed file 15 | from reopenclosedfile import * 16 | 17 | # location tracking is a custom feature for scite-with-python, but it's implemented in c++ 18 | def LocationNext(): 19 | ScApp.LocationNext() 20 | 21 | def LocationPrev(): 22 | ScApp.LocationPrev() 23 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_location/reopenclosedfile.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | import os 6 | from scite_extend_ui import ScEditor, ScApp 7 | 8 | # ctrl-shift-t to re-open a closed tab 9 | # useful because it's not limited to 20 entries 10 | gClosedTabs = [] 11 | gSavedSep = ord(' ') 12 | gSavedMaxHeight = 1 13 | def OnClose(file): 14 | if file not in gClosedTabs and os.path.isfile(file): 15 | gClosedTabs.insert(0, file) 16 | 17 | def OnOpen(file): 18 | # remove it from the list if it's opened in any form 19 | global gClosedTabs 20 | gClosedTabs = [item for item in gClosedTabs if item != file] 21 | 22 | def reopenClosedTab(): 23 | global gSavedSep, gSavedMaxHeight 24 | if len(gClosedTabs) > 0: 25 | gSavedSep = ScEditor.GetAutoCSeparator() 26 | gSavedMaxHeight = ScEditor.GetAutoCMaxHeight() 27 | itemList = '\n'.join(gClosedTabs) 28 | ScEditor.SetAutoCSeparator(ord('\n')) 29 | ScEditor.SetAutoCMaxHeight(20) 30 | ScEditor.UserListShow(ScEditor.UserListIDs.reopenClosedTabs, itemList) 31 | 32 | def OnUserListSelection(chosen, id): 33 | global gClosedTabs 34 | if id == ScEditor.UserListIDs.reopenClosedTabs: 35 | ScEditor.SetAutoCSeparator(gSavedSep) 36 | ScEditor.SetAutoCMaxHeight(gSavedMaxHeight) 37 | if os.path.isfile(chosen): 38 | # remove it from the list -- for example if filename is invalid, ensures it is no longer in the list 39 | gClosedTabs = [item for item in gClosedTabs if item != chosen] 40 | ScApp.OpenFile(chosen) 41 | else: 42 | print("No longer exists: " + chosen) 43 | 44 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_quick_info/register.properties: -------------------------------------------------------------------------------- 1 | 2 | *customcommandsregister.quick_info=quick_info| 3 | customcommand.quick_info.name=Commonly opened files... 4 | customcommand.quick_info.shortcut=Ctrl+M 5 | customcommand.quick_info.action.py=ThisModule().DoQuickInfo() 6 | customcommand.quick_info.path=tools_internal/tools_quick_info 7 | 8 | *customcommandsregister.quick_list_files_in_this_folder=quick_list_files_in_this_folder| 9 | customcommand.quick_list_files_in_this_folder.name=List files in this folder 10 | customcommand.quick_list_files_in_this_folder.shortcut=Ctrl+Shift+L 11 | customcommand.quick_list_files_in_this_folder.action.py=ThisModule().DoListFilesInFolder() 12 | customcommand.quick_list_files_in_this_folder.path=tools_internal/tools_quick_info 13 | 14 | # you can uncomment the line below to specify a 'scratch file' 15 | #customcommand.quick_info.scratchfilepath=path/to/temp/temp.py 16 | 17 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_regex_preview/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.regex_preview=regex_preview| 4 | customcommand.regex_preview.name=Preview regular expression... 5 | customcommand.regex_preview.shortcut=Ctrl+Alt+Shift+R 6 | customcommand.regex_preview.action.py=ThisModule().DoRegexPreviewTool() 7 | customcommand.regex_preview.path=tools_internal/tools_regex_preview 8 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_spelling_in_web_browser/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.spelling_in_web_browser=spelling_in_web_browser| 4 | customcommand.spelling_in_web_browser.name=Spellcheck selected text 5 | customcommand.spelling_in_web_browser.shortcut=Alt+F7 6 | customcommand.spelling_in_web_browser.action.py=ThisModule().SpellingInWebBrowser() 7 | customcommand.spelling_in_web_browser.path=tools_internal/tools_spelling_in_web_browser 8 | 9 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_spelling_in_web_browser/template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 10 | 11 | 12 |
13 | The selected text has been placed in the field below.
14 | Edits here will not be saved automatically,
they must be manually copied back into the source document. 15 |


16 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_switch_instance/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | import sys 6 | from scite_extend_ui import ScApp 7 | 8 | # inspired by SciTE-Ru's command 130 9 | 10 | def OpenInNewWindow(closeCurrent=True): 11 | from ben_python_common import files 12 | currentFile = ScApp.GetFilePath() 13 | 14 | if sys.platform.startswith('win'): 15 | scite = files.join(ScApp.GetSciteDirectory(), 'SciTE.exe') 16 | else: 17 | scite = '/usr/bin/SciTE_with_python' 18 | if not files.isfile(scite): 19 | scite = '/usr/local/bin/SciTE_with_python' 20 | 21 | if not files.isfile(scite): 22 | print('Could not find scite.') 23 | return 24 | else: 25 | args = [scite] 26 | args.append("-check.if.already.open=0") 27 | args.append("-save.session=0") 28 | 29 | # if there's an untitled document open, just start a new SciTE instance 30 | # otherwise, start a new SciTE instance and open the current file+line 31 | if currentFile and closeCurrent: 32 | ScApp.CmdClose() 33 | args.append(currentFile) 34 | args.append("-goto:%s,%s" % 35 | (ScApp.GetProperty('SelectionStartLine'), ScApp.GetProperty('SelectionStartColumn'))) 36 | 37 | files.run(args, createNoWindow=False, captureOutput=False, 38 | wait=False, throwOnFailure=None) 39 | 40 | def OpenNewDocInNewWindow(): 41 | OpenInNewWindow(closeCurrent=False) 42 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_switch_instance/register.properties: -------------------------------------------------------------------------------- 1 | 2 | *customcommandsregister.open_in_new_instance=open_in_new_instance| 3 | customcommand.open_in_new_instance.name=Open in new window 4 | customcommand.open_in_new_instance.path=tools_internal/tools_switch_instance 5 | customcommand.open_in_new_instance.shortcut=Ctrl+Shift+M 6 | customcommand.open_in_new_instance.action.py=ThisModule().OpenInNewWindow() 7 | 8 | *customcommandsregister.open_new_doc_in_new_instance=open_new_doc_in_new_instance| 9 | customcommand.open_new_doc_in_new_instance.name=Open new document in new window 10 | customcommand.open_new_doc_in_new_instance.path=tools_internal/tools_switch_instance 11 | customcommand.open_new_doc_in_new_instance.shortcut=Ctrl+Alt+Shift+M 12 | customcommand.open_new_doc_in_new_instance.action.py=ThisModule().OpenNewDocInNewWindow() 13 | 14 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_switch_to_header/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | def SwitchToHeader(): 6 | import switch_to_header 7 | switch_to_header.SwitchToHeader() 8 | 9 | def SwitchToCorrespondingDir(): 10 | import switch_to_corresponding_dir 11 | switch_to_corresponding_dir.SwitchToCorrespondingDir() 12 | 13 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_switch_to_header/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.switch_to_header=switch_to_header| 4 | customcommand.switch_to_header.name=Switch to header 5 | customcommand.switch_to_header.shortcut=Ctrl+Alt+H 6 | customcommand.switch_to_header.action.py=ThisModule().SwitchToHeader() 7 | customcommand.switch_to_header.path=tools_internal/tools_switch_to_header 8 | 9 | *customcommandsregister.switch_to_corresponding_dir=switch_to_corresponding_dir| 10 | customcommand.switch_to_corresponding_dir.name=Switch to file in corresponding folder 11 | customcommand.switch_to_corresponding_dir.shortcut=Ctrl+Shift+F10 12 | customcommand.switch_to_corresponding_dir.action.py=ThisModule().SwitchToCorrespondingDir() 13 | customcommand.switch_to_corresponding_dir.path=tools_internal/tools_switch_to_header 14 | 15 | 16 | # Sometimes you'll have two copies of a codebase in separate directories. 17 | # The "switch_to_corresponding_dir" plugin lets you quickly switch from one directory's version of a file to another. 18 | # for example, there are two files, c:\example\working\foo\bar\code.cpp and c:\example\master\foo\bar\code.cpp. 19 | # if you set up a mapping c:\example\working|c:\example\master in the list defined by 20 | # customcommand.switch_to_corresponding_dir.directorymappings, 21 | # you can open the file c:\example\working\foo\bar\code.cpp 22 | # run the "switch_to_corresponding_dir" plugin, 23 | # and then the plugin opens the corresponding file, c:\example\master\foo\bar\code.cpp. 24 | 25 | customcommand.switch_to_corresponding_dir.directorymappings=\ 26 | ||c:\example\working|c:\example\master\ 27 | ||c:\other_example\working|c:\other_example\master\ 28 | 29 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_text_information/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | def ShowSelectionInfo(): 6 | import show_selection_info 7 | show_selection_info.DoShowSelectionInfo() 8 | 9 | def ShowCodingReference(): 10 | import show_coding_reference 11 | show_coding_reference.DoShowCodingReference() 12 | 13 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_text_information/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | customcommand.open_in_hex_editor.binary=C:\data\data_3\software\FisherAppsFull\Utils\xvi32\XVI32.exe 4 | 5 | *customcommandsregister.show_selection_info=show_selection_info| 6 | customcommand.show_selection_info.name=Word count/sum... 7 | customcommand.show_selection_info.shortcut=Ctrl+Shift+3 8 | customcommand.show_selection_info.action.py=ThisModule().ShowSelectionInfo() 9 | customcommand.show_selection_info.path=tools_internal/tools_text_information 10 | 11 | *customcommandsregister.show_coding_reference=show_coding_reference| 12 | customcommand.show_coding_reference.name=Coding reference... 13 | customcommand.show_coding_reference.shortcut=Ctrl+Shift+I 14 | customcommand.show_coding_reference.action.py=ThisModule().ShowCodingReference() 15 | customcommand.show_coding_reference.path=tools_internal/tools_text_information 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_text_transformations/__init__.py: -------------------------------------------------------------------------------- 1 | # SciTE Python Extension 2 | # Ben Fisher, 2016 3 | # Released under the GNU General Public License version 3 4 | 5 | from changecasing import DoChangeCasing 6 | from changelines import DoChangeLines 7 | from movelines import MoveLinesUp, MoveLinesDown 8 | 9 | def modifyTextInScite(fn): 10 | from scite_extend_ui import ScEditor 11 | selected = ScEditor.GetSelectedText() 12 | if not selected: 13 | print('Nothing is selected.') 14 | return 15 | 16 | replaced = fn(selected) 17 | if replaced is None: 18 | return 19 | 20 | ScEditor.BeginUndoAction() 21 | try: 22 | # Using Write() would work, but it would lose the selection 23 | # Using InsertText() on the other hand, selects the text afterwards, which looks nice 24 | ScEditor.Clear() 25 | p = ScEditor.GetCurrentPos() 26 | ScEditor.InsertText(p, replaced) 27 | # This method scrolls the view to make caret visible 28 | ScEditor.SetSel(p, p + len(replaced)) 29 | finally: 30 | ScEditor.EndUndoAction() 31 | 32 | def modifyTextSupportsMultiSelection(fn, resetSelection): 33 | from scite_extend_ui import ScEditor 34 | sels = ScEditor.GetMultiSelect() 35 | if not sels: 36 | print('Nothing is selected.') 37 | return 38 | 39 | firstChar = sels[0][0] 40 | ScEditor.BeginUndoAction() 41 | try: 42 | for b in sels: 43 | txt = ScEditor.PaneGetText(b[0], b[1]) 44 | newtxt = fn(txt) 45 | ScEditor.PaneRemoveText(b[0], b[1]) 46 | ScEditor.PaneInsertText(newtxt, b[0]) 47 | if resetSelection: 48 | ScEditor.SetSel(firstChar, firstChar) 49 | finally: 50 | ScEditor.EndUndoAction() 51 | 52 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/tools_text_transformations/register.properties: -------------------------------------------------------------------------------- 1 | 2 | 3 | *customcommandsregister.text_changecasing=text_changecasing| 4 | customcommand.text_changecasing.name=Change casing... 5 | customcommand.text_changecasing.shortcut=Ctrl+U 6 | customcommand.text_changecasing.action.py=ThisModule().DoChangeCasing() 7 | customcommand.text_changecasing.path=tools_internal/tools_text_transformations 8 | 9 | *customcommandsregister.text_changelines=text_changelines| 10 | customcommand.text_changelines.name=Change lines... 11 | customcommand.text_changelines.shortcut=Ctrl+I 12 | customcommand.text_changelines.action.py=ThisModule().DoChangeLines() 13 | customcommand.text_changelines.path=tools_internal/tools_text_transformations 14 | 15 | *customcommandsregister.text_movelines1up=text_movelines1up| 16 | customcommand.text_movelines1up.name=Move line up 17 | customcommand.text_movelines1up.shortcut=Alt+Up 18 | customcommand.text_movelines1up.action.py=ThisModule().MoveLinesUp() 19 | customcommand.text_movelines1up.path=tools_internal/tools_text_transformations 20 | 21 | *customcommandsregister.text_movelines2down=text_movelines2down| 22 | customcommand.text_movelines2down.name=Move line down 23 | customcommand.text_movelines2down.shortcut=Alt+Down 24 | customcommand.text_movelines2down.action.py=ThisModule().MoveLinesDown() 25 | customcommand.text_movelines2down.path=tools_internal/tools_text_transformations 26 | 27 | 28 | -------------------------------------------------------------------------------- /src/scite/scite/bin/tools_internal/wincommondialog/wincommondialog.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/bin/tools_internal/wincommondialog/wincommondialog.zip -------------------------------------------------------------------------------- /src/scite/scite/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 | class DirectorExtension : public Extension { 9 | private: 10 | DirectorExtension() : inputWatcher(-1), inputChannel(0), host(0) {} // Singleton 11 | DirectorExtension(const DirectorExtension &); // Disable copy ctor 12 | void operator=(const DirectorExtension &); // Disable operator= 13 | 14 | public: 15 | static DirectorExtension &Instance(); 16 | 17 | // Implement the Extension interface 18 | virtual bool Initialise(ExtensionAPI *host_); 19 | virtual bool Finalise(); 20 | virtual bool Clear(); 21 | virtual bool Load(const char *filename); 22 | 23 | virtual bool OnOpen(const char *path); 24 | virtual bool OnSwitchFile(const char *path); 25 | virtual bool OnSave(const char *path); 26 | virtual bool OnChar(char ch); 27 | virtual bool OnExecute(const char *s); 28 | virtual bool OnSavePointReached(); 29 | virtual bool OnSavePointLeft(); 30 | virtual bool OnStyle(unsigned int startPos, int lengthDoc, int initStyle, StyleWriter *styler); 31 | virtual bool OnDoubleClick(); 32 | virtual bool OnUpdateUI(); 33 | virtual bool OnMarginClick(); 34 | virtual bool OnMacro(const char *command, const char *params); 35 | 36 | virtual bool SendProperty(const char *prop); 37 | virtual bool OnClose(const char *path); 38 | virtual bool NeedsOnClose(); 39 | 40 | // Allow messages through to extension 41 | void HandleStringMessage(const char *message); 42 | 43 | void CreatePipe(bool forceNew = false); 44 | private: 45 | int inputWatcher; 46 | GIOChannel *inputChannel; 47 | ExtensionAPI *host; 48 | }; 49 | 50 | -------------------------------------------------------------------------------- /src/scite/scite/gtk/GTKMutex.cxx: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file GTKMutex.cxx 3 | ** Define mutex 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 | // http://www.microsoft.com/msj/0797/win320797.aspx 10 | 11 | #include 12 | 13 | #include "Mutex.h" 14 | 15 | class GTKMutex : public Mutex { 16 | private: 17 | #if GLIB_CHECK_VERSION(2,31,0) 18 | GMutex m; 19 | #endif 20 | GMutex *pm; 21 | virtual void Lock() { 22 | g_mutex_lock(pm); 23 | } 24 | virtual void Unlock() { 25 | g_mutex_unlock(pm); 26 | } 27 | GTKMutex() { 28 | #if GLIB_CHECK_VERSION(2,31,0) 29 | pm = &m; 30 | g_mutex_init(pm); 31 | #else 32 | pm = g_mutex_new(); 33 | #endif 34 | } 35 | virtual ~GTKMutex() { 36 | #if GLIB_CHECK_VERSION(2,31,0) 37 | g_mutex_clear(pm); 38 | #else 39 | g_mutex_free(pm); 40 | #endif 41 | } 42 | friend class Mutex; 43 | }; 44 | 45 | Mutex *Mutex::Create() { 46 | return new GTKMutex(); 47 | } 48 | -------------------------------------------------------------------------------- /src/scite/scite/gtk/Sci48Mpy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/gtk/Sci48Mpy.png -------------------------------------------------------------------------------- /src/scite/scite/gtk/SciIcon.h: -------------------------------------------------------------------------------- 1 | /* XPM */ 2 | static const char * SciIcon_xpm[] = { 3 | "16 16 17 1", 4 | " c None", 5 | ". c #666666", 6 | "+ c #424242", 7 | "@ c #4D4D4D", 8 | "# c #777777", 9 | "$ c #555555", 10 | "% c #868686", 11 | "& c #333333", 12 | "* c #292929", 13 | "= c #A0A0A4", 14 | "- c #808080", 15 | "; c #C0C0C0", 16 | "> c #999999", 17 | ", c #E3E3E3", 18 | "' c #161616", 19 | ") c #B2B2B2", 20 | "! c #D7D7D7", 21 | " .+@@+# ", 22 | " $+$$@+@+@$ ", 23 | " $@+%&.@@@++@ ", 24 | " $@*=@-@-&.+&&@ ", 25 | " #+@;*>#&>&@+*+ ", 26 | ".$*;*,*=='..'++&", 27 | "+&.%#.,*$;&*.&*&", 28 | "*@)*,$+,@&=.'&.'", 29 | "*$&;*,$*!=*+%$''", 30 | "**@$)*;%*.;$***'", 31 | "*&&&&$*#-&*@+&''", 32 | " **&@*$**@+*''' ", 33 | " &*&+.'++*'*&** ", 34 | " **&*+&*&&*'' ", 35 | " ********'' ", 36 | " *''''' "}; 37 | -------------------------------------------------------------------------------- /src/scite/scite/gtk/SciTE_with_python.desktop: -------------------------------------------------------------------------------- 1 | [Desktop Entry] 2 | Encoding=UTF-8 3 | Version=1.0 4 | Name=SciTE with Python Text Editor 5 | Name[es]=Editor de textos SciTE 6 | Name[fr]=Éditeur de texte SciTE 7 | Name[ru]=Текстовый редактор SciTE 8 | Comment=Edit your source files 9 | Comment[es]=Edita especializado para programación 10 | Comment[fr]=Éditer des fichiers sources 11 | Comment[ru]=Редактор исходных кодов 12 | GenericName=Text Editor 13 | Type=Application 14 | Exec=SciTE_with_python %F 15 | Icon=Sci48Mpy 16 | Terminal=false 17 | StartupNotify=true 18 | Categories=TextEditor;Development;GTK;Application; 19 | MimeType=text/plain; 20 | -------------------------------------------------------------------------------- /src/scite/scite/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-2008 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 | -------------------------------------------------------------------------------- /src/scite/scite/lua/README: -------------------------------------------------------------------------------- 1 | README for Lua 5.1 2 | 3 | See INSTALL for installation instructions. 4 | See HISTORY for a summary of changes since the last released version. 5 | 6 | * What is Lua? 7 | ------------ 8 | Lua is a powerful, light-weight programming language designed for extending 9 | applications. Lua is also frequently used as a general-purpose, stand-alone 10 | language. Lua is free software. 11 | 12 | For complete information, visit Lua's web site at http://www.lua.org/ . 13 | For an executive summary, see http://www.lua.org/about.html . 14 | 15 | Lua has been used in many different projects around the world. 16 | For a short list, see http://www.lua.org/uses.html . 17 | 18 | * Availability 19 | ------------ 20 | Lua is freely available for both academic and commercial purposes. 21 | See COPYRIGHT and http://www.lua.org/license.html for details. 22 | Lua can be downloaded at http://www.lua.org/download.html . 23 | 24 | * Installation 25 | ------------ 26 | Lua is implemented in pure ANSI C, and compiles unmodified in all known 27 | platforms that have an ANSI C compiler. In most Unix-like platforms, simply 28 | do "make" with a suitable target. See INSTALL for detailed instructions. 29 | 30 | * Origin 31 | ------ 32 | Lua is developed at Lua.org, a laboratory of the Department of Computer 33 | Science of PUC-Rio (the Pontifical Catholic University of Rio de Janeiro 34 | in Brazil). 35 | For more information about the authors, see http://www.lua.org/authors.html . 36 | 37 | (end of README) 38 | -------------------------------------------------------------------------------- /src/scite/scite/lua/include/lualib.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 | /* Key to file-handle type */ 15 | #define LUA_FILEHANDLE "FILE*" 16 | 17 | 18 | #define LUA_COLIBNAME "coroutine" 19 | LUALIB_API int (luaopen_base) (lua_State *L); 20 | 21 | #define LUA_TABLIBNAME "table" 22 | LUALIB_API int (luaopen_table) (lua_State *L); 23 | 24 | #define LUA_IOLIBNAME "io" 25 | LUALIB_API int (luaopen_io) (lua_State *L); 26 | 27 | #define LUA_OSLIBNAME "os" 28 | LUALIB_API int (luaopen_os) (lua_State *L); 29 | 30 | #define LUA_STRLIBNAME "string" 31 | LUALIB_API int (luaopen_string) (lua_State *L); 32 | 33 | #define LUA_MATHLIBNAME "math" 34 | LUALIB_API int (luaopen_math) (lua_State *L); 35 | 36 | #define LUA_DBLIBNAME "debug" 37 | LUALIB_API int (luaopen_debug) (lua_State *L); 38 | 39 | #define LUA_LOADLIBNAME "package" 40 | LUALIB_API int (luaopen_package) (lua_State *L); 41 | 42 | 43 | /* open all previous libraries */ 44 | LUALIB_API void (luaL_openlibs) (lua_State *L); 45 | 46 | 47 | 48 | #ifndef lua_assert 49 | #define lua_assert(x) ((void)0) 50 | #endif 51 | 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 "lobject.h" 12 | 13 | 14 | LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o); 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/ldebug.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 getline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0) 17 | 18 | #define resethookcount(L) (L->hookcount = L->basehookcount) 19 | 20 | 21 | LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o, 22 | const char *opname); 23 | LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2); 24 | LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1, 25 | const TValue *p2); 26 | LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1, 27 | const TValue *p2); 28 | LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...); 29 | LUAI_FUNC void luaG_errormsg (lua_State *L); 30 | LUAI_FUNC int luaG_checkcode (const Proto *pt); 31 | LUAI_FUNC int luaG_checkopenop (Instruction i); 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lfunc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 | LUAI_FUNC Proto *luaF_newproto (lua_State *L); 22 | LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e); 23 | LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e); 24 | LUAI_FUNC UpVal *luaF_newupval (lua_State *L); 25 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); 26 | LUAI_FUNC void luaF_close (lua_State *L, StkId level); 27 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); 28 | LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c); 29 | LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv); 30 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, 31 | int pc); 32 | 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lib/linit.c: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 3 | ** Initialization of libraries for lua.c 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | 8 | #define linit_c 9 | #define LUA_LIB 10 | 11 | #include "lua.h" 12 | 13 | #include "lualib.h" 14 | #include "lauxlib.h" 15 | 16 | 17 | static const luaL_Reg lualibs[] = { 18 | {"", luaopen_base}, 19 | {LUA_LOADLIBNAME, luaopen_package}, 20 | {LUA_TABLIBNAME, luaopen_table}, 21 | {LUA_IOLIBNAME, luaopen_io}, 22 | {LUA_OSLIBNAME, luaopen_os}, 23 | {LUA_STRLIBNAME, luaopen_string}, 24 | {LUA_MATHLIBNAME, luaopen_math}, 25 | {LUA_DBLIBNAME, luaopen_debug}, 26 | {NULL, NULL} 27 | }; 28 | 29 | 30 | LUALIB_API void luaL_openlibs (lua_State *L) { 31 | const luaL_Reg *lib = lualibs; 32 | for (; lib->func; lib++) { 33 | lua_pushcfunction(L, lib->func); 34 | lua_pushstring(L, lib->name); 35 | lua_call(L, 1, 0); 36 | } 37 | } 38 | 39 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lmem.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 | #define MEMERRMSG "not enough memory" 17 | 18 | 19 | #define luaM_reallocv(L,b,on,n,e) \ 20 | ((cast(size_t, (n)+1) <= MAX_SIZET/(e)) ? /* +1 to avoid warnings */ \ 21 | luaM_realloc_(L, (b), (on)*(e), (n)*(e)) : \ 22 | luaM_toobig(L)) 23 | 24 | #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0) 25 | #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0) 26 | #define luaM_freearray(L, b, n, t) luaM_reallocv(L, (b), n, 0, sizeof(t)) 27 | 28 | #define luaM_malloc(L,t) luaM_realloc_(L, NULL, 0, (t)) 29 | #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t))) 30 | #define luaM_newvector(L,n,t) \ 31 | cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t))) 32 | 33 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \ 34 | if ((nelems)+1 > (size)) \ 35 | ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e))) 36 | 37 | #define luaM_reallocvector(L, v,oldn,n,t) \ 38 | ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t)))) 39 | 40 | 41 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, 42 | size_t size); 43 | LUAI_FUNC void *luaM_toobig (lua_State *L); 44 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size, 45 | size_t size_elem, int limit, 46 | const char *errormsg); 47 | 48 | #endif 49 | 50 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lstring.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 | 11 | #include "lgc.h" 12 | #include "lobject.h" 13 | #include "lstate.h" 14 | 15 | 16 | #define sizestring(s) (sizeof(union TString)+((s)->len+1)*sizeof(char)) 17 | 18 | #define sizeudata(u) (sizeof(union Udata)+(u)->len) 19 | 20 | #define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s))) 21 | #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ 22 | (sizeof(s)/sizeof(char))-1)) 23 | 24 | #define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT) 25 | 26 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize); 27 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e); 28 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); 29 | 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/ltable.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 gkey(n) (&(n)->i_key.nk) 15 | #define gval(n) (&(n)->i_val) 16 | #define gnext(n) ((n)->i_key.nk.next) 17 | 18 | #define key2tval(n) (&(n)->i_key.tvk) 19 | 20 | 21 | LUAI_FUNC const TValue *luaH_getnum (Table *t, int key); 22 | LUAI_FUNC TValue *luaH_setnum (lua_State *L, Table *t, int key); 23 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); 24 | LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key); 25 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); 26 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); 27 | LUAI_FUNC Table *luaH_new (lua_State *L, int narray, int lnhash); 28 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize); 29 | LUAI_FUNC void luaH_free (lua_State *L, Table *t); 30 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); 31 | LUAI_FUNC int luaH_getn (Table *t); 32 | 33 | 34 | #if defined(LUA_DEBUG) 35 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); 36 | LUAI_FUNC int luaH_isdummy (Node *n); 37 | #endif 38 | 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/ltm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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" 17 | */ 18 | typedef enum { 19 | TM_INDEX, 20 | TM_NEWINDEX, 21 | TM_GC, 22 | TM_MODE, 23 | TM_EQ, /* last tag method with `fast' access */ 24 | TM_ADD, 25 | TM_SUB, 26 | TM_MUL, 27 | TM_DIV, 28 | TM_MOD, 29 | TM_POW, 30 | TM_UNM, 31 | TM_LEN, 32 | TM_LT, 33 | TM_LE, 34 | TM_CONCAT, 35 | TM_CALL, 36 | TM_N /* number of elements in the enum */ 37 | } TMS; 38 | 39 | 40 | 41 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \ 42 | ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) 43 | 44 | #define fasttm(l,et,e) gfasttm(G(l), et, e) 45 | 46 | LUAI_DATA const char *const luaT_typenames[]; 47 | 48 | 49 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); 50 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, 51 | TMS event); 52 | LUAI_FUNC void luaT_init (lua_State *L); 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lundump.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 "lobject.h" 11 | #include "lzio.h" 12 | 13 | /* load one chunk; from lundump.c */ 14 | LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name); 15 | 16 | /* make header; from lundump.c */ 17 | LUAI_FUNC void luaU_header (char* h); 18 | 19 | /* dump one chunk; from ldump.c */ 20 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip); 21 | 22 | #ifdef luac_c 23 | /* print one chunk; from print.c */ 24 | LUAI_FUNC void luaU_print (const Proto* f, int full); 25 | #endif 26 | 27 | /* for header of binary files -- this is Lua 5.1 */ 28 | #define LUAC_VERSION 0x51 29 | 30 | /* for header of binary files -- this is the official format */ 31 | #define LUAC_FORMAT 0 32 | 33 | /* size of header of binary files */ 34 | #define LUAC_HEADERSIZE 12 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lvm.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 3 | ** Lua virtual machine 4 | ** See Copyright Notice in lua.h 5 | */ 6 | 7 | #ifndef lvm_h 8 | #define lvm_h 9 | 10 | 11 | #include "ldo.h" 12 | #include "lobject.h" 13 | #include "ltm.h" 14 | 15 | 16 | #define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o))) 17 | 18 | #define tonumber(o,n) (ttype(o) == LUA_TNUMBER || \ 19 | (((o) = luaV_tonumber(o,n)) != NULL)) 20 | 21 | #define equalobj(L,o1,o2) \ 22 | (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2)) 23 | 24 | 25 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); 26 | LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2); 27 | LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); 28 | LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); 29 | LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, 30 | StkId val); 31 | LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, 32 | StkId val); 33 | LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls); 34 | LUAI_FUNC void luaV_concat (lua_State *L, int total, int last); 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/scite/scite/lua/src/lzio.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** $Id$ 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 char2int(c) cast(int, cast(unsigned char, (c))) 21 | 22 | #define zgetc(z) (((z)->n--)>0 ? char2int(*(z)->p++) : luaZ_fill(z)) 23 | 24 | typedef struct Mbuffer { 25 | char *buffer; 26 | size_t n; 27 | size_t buffsize; 28 | } Mbuffer; 29 | 30 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) 31 | 32 | #define luaZ_buffer(buff) ((buff)->buffer) 33 | #define luaZ_sizebuffer(buff) ((buff)->buffsize) 34 | #define luaZ_bufflen(buff) ((buff)->n) 35 | 36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0) 37 | 38 | 39 | #define luaZ_resizebuffer(L, buff, size) \ 40 | (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ 41 | (buff)->buffsize = size) 42 | 43 | #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) 44 | 45 | 46 | LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); 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 | LUAI_FUNC int luaZ_lookahead (ZIO *z); 51 | 52 | 53 | 54 | /* --------- Private Part ------------------ */ 55 | 56 | struct Zio { 57 | size_t n; /* bytes still unread */ 58 | const char *p; /* current position in buffer */ 59 | lua_Reader reader; 60 | void* data; /* additional data */ 61 | lua_State *L; /* Lua state (for reader) */ 62 | }; 63 | 64 | 65 | LUAI_FUNC int luaZ_fill (ZIO *z); 66 | 67 | #endif 68 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/asdl.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ASDL_H 2 | #define Py_ASDL_H 3 | 4 | typedef PyObject * identifier; 5 | typedef PyObject * string; 6 | typedef PyObject * object; 7 | 8 | #ifndef __cplusplus 9 | typedef enum {false, true} bool; 10 | #endif 11 | 12 | /* It would be nice if the code generated by asdl_c.py was completely 13 | independent of Python, but it is a goal the requires too much work 14 | at this stage. So, for example, I'll represent identifiers as 15 | interned Python strings. 16 | */ 17 | 18 | /* XXX A sequence should be typed so that its use can be typechecked. */ 19 | 20 | typedef struct { 21 | int size; 22 | void *elements[1]; 23 | } asdl_seq; 24 | 25 | typedef struct { 26 | int size; 27 | int elements[1]; 28 | } asdl_int_seq; 29 | 30 | asdl_seq *asdl_seq_new(int size, PyArena *arena); 31 | asdl_int_seq *asdl_int_seq_new(int size, PyArena *arena); 32 | 33 | #define asdl_seq_GET(S, I) (S)->elements[(I)] 34 | #define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size) 35 | #ifdef Py_DEBUG 36 | #define asdl_seq_SET(S, I, V) { \ 37 | int _asdl_i = (I); \ 38 | assert((S) && _asdl_i < (S)->size); \ 39 | (S)->elements[_asdl_i] = (V); \ 40 | } 41 | #else 42 | #define asdl_seq_SET(S, I, V) (S)->elements[I] = (V) 43 | #endif 44 | 45 | #endif /* !Py_ASDL_H */ 46 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/ast.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_AST_H 2 | #define Py_AST_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(mod_ty) PyAST_FromNode(const node *, PyCompilerFlags *flags, 8 | const char *, PyArena *); 9 | 10 | #ifdef __cplusplus 11 | } 12 | #endif 13 | #endif /* !Py_AST_H */ 14 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/bitset.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_BITSET_H 3 | #define Py_BITSET_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | /* Bitset interface */ 9 | 10 | #define BYTE char 11 | 12 | typedef BYTE *bitset; 13 | 14 | bitset newbitset(int nbits); 15 | void delbitset(bitset bs); 16 | #define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0) 17 | int addbit(bitset bs, int ibit); /* Returns 0 if already set */ 18 | int samebitset(bitset bs1, bitset bs2, int nbits); 19 | void mergebitset(bitset bs1, bitset bs2, int nbits); 20 | 21 | #define BITSPERBYTE (8*sizeof(BYTE)) 22 | #define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE) 23 | 24 | #define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE) 25 | #define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE) 26 | #define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit)) 27 | #define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE) 28 | 29 | #ifdef __cplusplus 30 | } 31 | #endif 32 | #endif /* !Py_BITSET_H */ 33 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/boolobject.h: -------------------------------------------------------------------------------- 1 | /* Boolean object interface */ 2 | 3 | #ifndef Py_BOOLOBJECT_H 4 | #define Py_BOOLOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | 10 | typedef PyIntObject PyBoolObject; 11 | 12 | PyAPI_DATA(PyTypeObject) PyBool_Type; 13 | 14 | #define PyBool_Check(x) (Py_TYPE(x) == &PyBool_Type) 15 | 16 | /* Py_False and Py_True are the only two bools in existence. 17 | Don't forget to apply Py_INCREF() when returning either!!! */ 18 | 19 | /* Don't use these directly */ 20 | PyAPI_DATA(PyIntObject) _Py_ZeroStruct, _Py_TrueStruct; 21 | 22 | /* Use these macros */ 23 | #define Py_False ((PyObject *) &_Py_ZeroStruct) 24 | #define Py_True ((PyObject *) &_Py_TrueStruct) 25 | 26 | /* Macros for returning Py_True or Py_False, respectively */ 27 | #define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True 28 | #define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False 29 | 30 | /* Function to return a bool from a C long */ 31 | PyAPI_FUNC(PyObject *) PyBool_FromLong(long); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_BOOLOBJECT_H */ 37 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/bufferobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Buffer object interface */ 3 | 4 | /* Note: the object's structure is private */ 5 | 6 | #ifndef Py_BUFFEROBJECT_H 7 | #define Py_BUFFEROBJECT_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | 13 | PyAPI_DATA(PyTypeObject) PyBuffer_Type; 14 | 15 | #define PyBuffer_Check(op) (Py_TYPE(op) == &PyBuffer_Type) 16 | 17 | #define Py_END_OF_BUFFER (-1) 18 | 19 | PyAPI_FUNC(PyObject *) PyBuffer_FromObject(PyObject *base, 20 | Py_ssize_t offset, Py_ssize_t size); 21 | PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteObject(PyObject *base, 22 | Py_ssize_t offset, 23 | Py_ssize_t size); 24 | 25 | PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, Py_ssize_t size); 26 | PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size); 27 | 28 | PyAPI_FUNC(PyObject *) PyBuffer_New(Py_ssize_t size); 29 | 30 | #ifdef __cplusplus 31 | } 32 | #endif 33 | #endif /* !Py_BUFFEROBJECT_H */ 34 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/bytesobject.h: -------------------------------------------------------------------------------- 1 | #define PyBytesObject PyStringObject 2 | #define PyBytes_Type PyString_Type 3 | 4 | #define PyBytes_Check PyString_Check 5 | #define PyBytes_CheckExact PyString_CheckExact 6 | #define PyBytes_CHECK_INTERNED PyString_CHECK_INTERNED 7 | #define PyBytes_AS_STRING PyString_AS_STRING 8 | #define PyBytes_GET_SIZE PyString_GET_SIZE 9 | #define Py_TPFLAGS_BYTES_SUBCLASS Py_TPFLAGS_STRING_SUBCLASS 10 | 11 | #define PyBytes_FromStringAndSize PyString_FromStringAndSize 12 | #define PyBytes_FromString PyString_FromString 13 | #define PyBytes_FromFormatV PyString_FromFormatV 14 | #define PyBytes_FromFormat PyString_FromFormat 15 | #define PyBytes_Size PyString_Size 16 | #define PyBytes_AsString PyString_AsString 17 | #define PyBytes_Repr PyString_Repr 18 | #define PyBytes_Concat PyString_Concat 19 | #define PyBytes_ConcatAndDel PyString_ConcatAndDel 20 | #define _PyBytes_Resize _PyString_Resize 21 | #define _PyBytes_Eq _PyString_Eq 22 | #define PyBytes_Format PyString_Format 23 | #define _PyBytes_FormatLong _PyString_FormatLong 24 | #define PyBytes_DecodeEscape PyString_DecodeEscape 25 | #define _PyBytes_Join _PyString_Join 26 | #define PyBytes_AsStringAndSize PyString_AsStringAndSize 27 | #define _PyBytes_InsertThousandsGrouping _PyString_InsertThousandsGrouping 28 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/cellobject.h: -------------------------------------------------------------------------------- 1 | /* Cell object interface */ 2 | 3 | #ifndef Py_CELLOBJECT_H 4 | #define Py_CELLOBJECT_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | typedef struct { 10 | PyObject_HEAD 11 | PyObject *ob_ref; /* Content of the cell or NULL when empty */ 12 | } PyCellObject; 13 | 14 | PyAPI_DATA(PyTypeObject) PyCell_Type; 15 | 16 | #define PyCell_Check(op) (Py_TYPE(op) == &PyCell_Type) 17 | 18 | PyAPI_FUNC(PyObject *) PyCell_New(PyObject *); 19 | PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *); 20 | PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *); 21 | 22 | #define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref) 23 | #define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v) 24 | 25 | #ifdef __cplusplus 26 | } 27 | #endif 28 | #endif /* !Py_TUPLEOBJECT_H */ 29 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/compile.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_COMPILE_H 3 | #define Py_COMPILE_H 4 | 5 | #include "code.h" 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | /* Public interface */ 12 | struct _node; /* Declare the existence of this type */ 13 | PyAPI_FUNC(PyCodeObject *) PyNode_Compile(struct _node *, const char *); 14 | 15 | /* Future feature support */ 16 | 17 | typedef struct { 18 | int ff_features; /* flags set by future statements */ 19 | int ff_lineno; /* line number of last future statement */ 20 | } PyFutureFeatures; 21 | 22 | #define FUTURE_NESTED_SCOPES "nested_scopes" 23 | #define FUTURE_GENERATORS "generators" 24 | #define FUTURE_DIVISION "division" 25 | #define FUTURE_ABSOLUTE_IMPORT "absolute_import" 26 | #define FUTURE_WITH_STATEMENT "with_statement" 27 | #define FUTURE_PRINT_FUNCTION "print_function" 28 | #define FUTURE_UNICODE_LITERALS "unicode_literals" 29 | 30 | 31 | struct _mod; /* Declare the existence of this type */ 32 | PyAPI_FUNC(PyCodeObject *) PyAST_Compile(struct _mod *, const char *, 33 | PyCompilerFlags *, PyArena *); 34 | PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(struct _mod *, const char *); 35 | 36 | 37 | #ifdef __cplusplus 38 | } 39 | #endif 40 | #endif /* !Py_COMPILE_H */ 41 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/dtoa.h: -------------------------------------------------------------------------------- 1 | #ifndef PY_NO_SHORT_FLOAT_REPR 2 | #ifdef __cplusplus 3 | extern "C" { 4 | #endif 5 | 6 | PyAPI_FUNC(double) _Py_dg_strtod(const char *str, char **ptr); 7 | PyAPI_FUNC(char *) _Py_dg_dtoa(double d, int mode, int ndigits, 8 | int *decpt, int *sign, char **rve); 9 | PyAPI_FUNC(void) _Py_dg_freedtoa(char *s); 10 | 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | #endif 16 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/enumobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ENUMOBJECT_H 2 | #define Py_ENUMOBJECT_H 3 | 4 | /* Enumerate Object */ 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_DATA(PyTypeObject) PyEnum_Type; 11 | PyAPI_DATA(PyTypeObject) PyReversed_Type; 12 | 13 | #ifdef __cplusplus 14 | } 15 | #endif 16 | 17 | #endif /* !Py_ENUMOBJECT_H */ 18 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/errcode.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ERRCODE_H 2 | #define Py_ERRCODE_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Error codes passed around between file input, tokenizer, parser and 9 | interpreter. This is necessary so we can turn them into Python 10 | exceptions at a higher level. Note that some errors have a 11 | slightly different meaning when passed from the tokenizer to the 12 | parser than when passed from the parser to the interpreter; e.g. 13 | the parser only returns E_EOF when it hits EOF immediately, and it 14 | never returns E_OK. */ 15 | 16 | #define E_OK 10 /* No error */ 17 | #define E_EOF 11 /* End Of File */ 18 | #define E_INTR 12 /* Interrupted */ 19 | #define E_TOKEN 13 /* Bad token */ 20 | #define E_SYNTAX 14 /* Syntax error */ 21 | #define E_NOMEM 15 /* Ran out of memory */ 22 | #define E_DONE 16 /* Parsing complete */ 23 | #define E_ERROR 17 /* Execution error */ 24 | #define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */ 25 | #define E_OVERFLOW 19 /* Node had too many children */ 26 | #define E_TOODEEP 20 /* Too many indentation levels */ 27 | #define E_DEDENT 21 /* No matching outer block for dedent */ 28 | #define E_DECODE 22 /* Error in decoding into Unicode */ 29 | #define E_EOFS 23 /* EOF in triple-quoted string */ 30 | #define E_EOLS 24 /* EOL in single-quoted string */ 31 | #define E_LINECONT 25 /* Unexpected characters after a line continuation */ 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | #endif /* !Py_ERRCODE_H */ 37 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/eval.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interface to execute compiled code */ 3 | 4 | #ifndef Py_EVAL_H 5 | #define Py_EVAL_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyCodeObject *, PyObject *, PyObject *); 11 | 12 | PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyCodeObject *co, 13 | PyObject *globals, 14 | PyObject *locals, 15 | PyObject **args, int argc, 16 | PyObject **kwds, int kwdc, 17 | PyObject **defs, int defc, 18 | PyObject *closure); 19 | 20 | PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_EVAL_H */ 26 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/genobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Generator object interface */ 3 | 4 | #ifndef Py_GENOBJECT_H 5 | #define Py_GENOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | struct _frame; /* Avoid including frameobject.h */ 11 | 12 | typedef struct { 13 | PyObject_HEAD 14 | /* The gi_ prefix is intended to remind of generator-iterator. */ 15 | 16 | /* Note: gi_frame can be NULL if the generator is "finished" */ 17 | struct _frame *gi_frame; 18 | 19 | /* True if generator is being executed. */ 20 | int gi_running; 21 | 22 | /* The code object backing the generator */ 23 | PyObject *gi_code; 24 | 25 | /* List of weak reference. */ 26 | PyObject *gi_weakreflist; 27 | } PyGenObject; 28 | 29 | PyAPI_DATA(PyTypeObject) PyGen_Type; 30 | 31 | #define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type) 32 | #define PyGen_CheckExact(op) (Py_TYPE(op) == &PyGen_Type) 33 | 34 | PyAPI_FUNC(PyObject *) PyGen_New(struct _frame *); 35 | PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *); 36 | 37 | #ifdef __cplusplus 38 | } 39 | #endif 40 | #endif /* !Py_GENOBJECT_H */ 41 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/intrcheck.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_INTRCHECK_H 3 | #define Py_INTRCHECK_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(int) PyOS_InterruptOccurred(void); 9 | PyAPI_FUNC(void) PyOS_InitInterrupts(void); 10 | PyAPI_FUNC(void) PyOS_AfterFork(void); 11 | 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | #endif /* !Py_INTRCHECK_H */ 16 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/iterobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_ITEROBJECT_H 2 | #define Py_ITEROBJECT_H 3 | /* Iterators (the basic kind, over a sequence) */ 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_DATA(PyTypeObject) PySeqIter_Type; 9 | 10 | #define PySeqIter_Check(op) (Py_TYPE(op) == &PySeqIter_Type) 11 | 12 | PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); 13 | 14 | PyAPI_DATA(PyTypeObject) PyCallIter_Type; 15 | 16 | #define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type) 17 | 18 | PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_ITEROBJECT_H */ 23 | 24 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/marshal.h: -------------------------------------------------------------------------------- 1 | 2 | /* Interface for marshal.c */ 3 | 4 | #ifndef Py_MARSHAL_H 5 | #define Py_MARSHAL_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | #define Py_MARSHAL_VERSION 2 11 | 12 | PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int); 13 | PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int); 14 | PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int); 15 | 16 | PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *); 17 | PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *); 18 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *); 19 | PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *); 20 | PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | #endif /* !Py_MARSHAL_H */ 26 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/metagrammar.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_METAGRAMMAR_H 2 | #define Py_METAGRAMMAR_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | #define MSTART 256 9 | #define RULE 257 10 | #define RHS 258 11 | #define ALT 259 12 | #define ITEM 260 13 | #define ATOM 261 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | #endif /* !Py_METAGRAMMAR_H */ 19 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/moduleobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Module object interface */ 3 | 4 | #ifndef Py_MODULEOBJECT_H 5 | #define Py_MODULEOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_DATA(PyTypeObject) PyModule_Type; 11 | 12 | #define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type) 13 | #define PyModule_CheckExact(op) (Py_TYPE(op) == &PyModule_Type) 14 | 15 | PyAPI_FUNC(PyObject *) PyModule_New(const char *); 16 | PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *); 17 | PyAPI_FUNC(char *) PyModule_GetName(PyObject *); 18 | PyAPI_FUNC(char *) PyModule_GetFilename(PyObject *); 19 | PyAPI_FUNC(void) _PyModule_Clear(PyObject *); 20 | 21 | #ifdef __cplusplus 22 | } 23 | #endif 24 | #endif /* !Py_MODULEOBJECT_H */ 25 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/node.h: -------------------------------------------------------------------------------- 1 | 2 | /* Parse tree node interface */ 3 | 4 | #ifndef Py_NODE_H 5 | #define Py_NODE_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct _node { 11 | short n_type; 12 | char *n_str; 13 | int n_lineno; 14 | int n_col_offset; 15 | int n_nchildren; 16 | struct _node *n_child; 17 | } node; 18 | 19 | PyAPI_FUNC(node *) PyNode_New(int type); 20 | PyAPI_FUNC(int) PyNode_AddChild(node *n, int type, 21 | char *str, int lineno, int col_offset); 22 | PyAPI_FUNC(void) PyNode_Free(node *n); 23 | PyAPI_FUNC(Py_ssize_t) _PyNode_SizeOf(node *n); 24 | 25 | /* Node access functions */ 26 | #define NCH(n) ((n)->n_nchildren) 27 | 28 | #define CHILD(n, i) (&(n)->n_child[i]) 29 | #define RCHILD(n, i) (CHILD(n, NCH(n) + i)) 30 | #define TYPE(n) ((n)->n_type) 31 | #define STR(n) ((n)->n_str) 32 | 33 | /* Assert that the type of a node is what we expect */ 34 | #define REQ(n, type) assert(TYPE(n) == (type)) 35 | 36 | PyAPI_FUNC(void) PyNode_ListTree(node *); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | #endif /* !Py_NODE_H */ 42 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/osdefs.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_OSDEFS_H 2 | #define Py_OSDEFS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Operating system dependencies */ 9 | 10 | /* Mod by chrish: QNX has WATCOM, but isn't DOS */ 11 | #if !defined(__QNX__) 12 | #if defined(MS_WINDOWS) || defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__DJGPP__) || defined(PYOS_OS2) 13 | #if defined(PYOS_OS2) && defined(PYCC_GCC) 14 | #define MAXPATHLEN 260 15 | #define SEP '/' 16 | #define ALTSEP '\\' 17 | #else 18 | #define SEP '\\' 19 | #define ALTSEP '/' 20 | #define MAXPATHLEN 256 21 | #endif 22 | #define DELIM ';' 23 | #endif 24 | #endif 25 | 26 | #ifdef RISCOS 27 | #define SEP '.' 28 | #define MAXPATHLEN 256 29 | #define DELIM ',' 30 | #endif 31 | 32 | 33 | /* Filename separator */ 34 | #ifndef SEP 35 | #define SEP '/' 36 | #endif 37 | 38 | /* Max pathname length */ 39 | #ifdef __hpux 40 | #include 41 | #include 42 | #ifndef PATH_MAX 43 | #define PATH_MAX MAXPATHLEN 44 | #endif 45 | #endif 46 | 47 | #ifndef MAXPATHLEN 48 | #if defined(PATH_MAX) && PATH_MAX > 1024 49 | #define MAXPATHLEN PATH_MAX 50 | #else 51 | #define MAXPATHLEN 1024 52 | #endif 53 | #endif 54 | 55 | /* Search path entry delimiter */ 56 | #ifndef DELIM 57 | #define DELIM ':' 58 | #endif 59 | 60 | #ifdef __cplusplus 61 | } 62 | #endif 63 | #endif /* !Py_OSDEFS_H */ 64 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/patchlevel.h: -------------------------------------------------------------------------------- 1 | 2 | /* Newfangled version identification scheme. 3 | 4 | This scheme was added in Python 1.5.2b2; before that time, only PATCHLEVEL 5 | was available. To test for presence of the scheme, test for 6 | defined(PY_MAJOR_VERSION). 7 | 8 | When the major or minor version changes, the VERSION variable in 9 | configure.ac must also be changed. 10 | 11 | There is also (independent) API version information in modsupport.h. 12 | */ 13 | 14 | /* Values for PY_RELEASE_LEVEL */ 15 | #define PY_RELEASE_LEVEL_ALPHA 0xA 16 | #define PY_RELEASE_LEVEL_BETA 0xB 17 | #define PY_RELEASE_LEVEL_GAMMA 0xC /* For release candidates */ 18 | #define PY_RELEASE_LEVEL_FINAL 0xF /* Serial should be 0 here */ 19 | /* Higher for patch releases */ 20 | 21 | /* Version parsed out into numeric values */ 22 | /*--start constants--*/ 23 | #define PY_MAJOR_VERSION 2 24 | #define PY_MINOR_VERSION 7 25 | #define PY_MICRO_VERSION 12 26 | #define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL 27 | #define PY_RELEASE_SERIAL 0 28 | 29 | /* Version as a string */ 30 | #define PY_VERSION "2.7.12" 31 | /*--end constants--*/ 32 | 33 | /* Subversion Revision number of this file (not of the repository). Empty 34 | since Mercurial migration. */ 35 | #define PY_PATCHLEVEL_REVISION "" 36 | 37 | /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. 38 | Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */ 39 | #define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \ 40 | (PY_MINOR_VERSION << 16) | \ 41 | (PY_MICRO_VERSION << 8) | \ 42 | (PY_RELEASE_LEVEL << 4) | \ 43 | (PY_RELEASE_SERIAL << 0)) 44 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pgen.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_PGEN_H 2 | #define Py_PGEN_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Parser generator interface */ 9 | 10 | extern grammar *meta_grammar(void); 11 | 12 | struct _node; 13 | extern grammar *pgen(struct _node *); 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | #endif /* !Py_PGEN_H */ 19 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pgenheaders.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_PGENHEADERS_H 2 | #define Py_PGENHEADERS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | 8 | /* Include files and extern declarations used by most of the parser. */ 9 | 10 | #include "Python.h" 11 | 12 | PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...) 13 | Py_GCC_ATTRIBUTE((format(printf, 1, 2))); 14 | PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...) 15 | Py_GCC_ATTRIBUTE((format(printf, 1, 2))); 16 | 17 | #define addarc _Py_addarc 18 | #define addbit _Py_addbit 19 | #define adddfa _Py_adddfa 20 | #define addfirstsets _Py_addfirstsets 21 | #define addlabel _Py_addlabel 22 | #define addstate _Py_addstate 23 | #define delbitset _Py_delbitset 24 | #define dumptree _Py_dumptree 25 | #define findlabel _Py_findlabel 26 | #define mergebitset _Py_mergebitset 27 | #define meta_grammar _Py_meta_grammar 28 | #define newbitset _Py_newbitset 29 | #define newgrammar _Py_newgrammar 30 | #define pgen _Py_pgen 31 | #define printgrammar _Py_printgrammar 32 | #define printnonterminals _Py_printnonterminals 33 | #define printtree _Py_printtree 34 | #define samebitset _Py_samebitset 35 | #define showtree _Py_showtree 36 | #define tok_dump _Py_tok_dump 37 | #define translatelabels _Py_translatelabels 38 | 39 | #ifdef __cplusplus 40 | } 41 | #endif 42 | #endif /* !Py_PGENHEADERS_H */ 43 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pyctype.h: -------------------------------------------------------------------------------- 1 | #ifndef PYCTYPE_H 2 | #define PYCTYPE_H 3 | 4 | #define PY_CTF_LOWER 0x01 5 | #define PY_CTF_UPPER 0x02 6 | #define PY_CTF_ALPHA (PY_CTF_LOWER|PY_CTF_UPPER) 7 | #define PY_CTF_DIGIT 0x04 8 | #define PY_CTF_ALNUM (PY_CTF_ALPHA|PY_CTF_DIGIT) 9 | #define PY_CTF_SPACE 0x08 10 | #define PY_CTF_XDIGIT 0x10 11 | 12 | PyAPI_DATA(const unsigned int) _Py_ctype_table[256]; 13 | 14 | /* Unlike their C counterparts, the following macros are not meant to 15 | * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument 16 | * must be a signed/unsigned char. */ 17 | #define Py_ISLOWER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER) 18 | #define Py_ISUPPER(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER) 19 | #define Py_ISALPHA(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA) 20 | #define Py_ISDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT) 21 | #define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT) 22 | #define Py_ISALNUM(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM) 23 | #define Py_ISSPACE(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE) 24 | 25 | PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256]; 26 | PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256]; 27 | 28 | #define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)]) 29 | #define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)]) 30 | 31 | #endif /* !PYCTYPE_H */ 32 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pydebug.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_PYDEBUG_H 3 | #define Py_PYDEBUG_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_DATA(int) Py_DebugFlag; 9 | PyAPI_DATA(int) Py_VerboseFlag; 10 | PyAPI_DATA(int) Py_InteractiveFlag; 11 | PyAPI_DATA(int) Py_InspectFlag; 12 | PyAPI_DATA(int) Py_OptimizeFlag; 13 | PyAPI_DATA(int) Py_NoSiteFlag; 14 | PyAPI_DATA(int) Py_BytesWarningFlag; 15 | PyAPI_DATA(int) Py_UseClassExceptionsFlag; 16 | PyAPI_DATA(int) Py_FrozenFlag; 17 | PyAPI_DATA(int) Py_TabcheckFlag; 18 | PyAPI_DATA(int) Py_UnicodeFlag; 19 | PyAPI_DATA(int) Py_IgnoreEnvironmentFlag; 20 | PyAPI_DATA(int) Py_DivisionWarningFlag; 21 | PyAPI_DATA(int) Py_DontWriteBytecodeFlag; 22 | PyAPI_DATA(int) Py_NoUserSiteDirectory; 23 | /* _XXX Py_QnewFlag should go away in 3.0. It's true iff -Qnew is passed, 24 | on the command line, and is used in 2.2 by ceval.c to make all "/" divisions 25 | true divisions (which they will be in 3.0). */ 26 | PyAPI_DATA(int) _Py_QnewFlag; 27 | /* Warn about 3.x issues */ 28 | PyAPI_DATA(int) Py_Py3kWarningFlag; 29 | PyAPI_DATA(int) Py_HashRandomizationFlag; 30 | 31 | /* this is a wrapper around getenv() that pays attention to 32 | Py_IgnoreEnvironmentFlag. It should be used for getting variables like 33 | PYTHONPATH and PYTHONHOME from the environment */ 34 | #define Py_GETENV(s) (Py_IgnoreEnvironmentFlag ? NULL : getenv(s)) 35 | 36 | PyAPI_FUNC(void) Py_FatalError(const char *message); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | #endif /* !Py_PYDEBUG_H */ 42 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pygetopt.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_PYGETOPT_H 3 | #define Py_PYGETOPT_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_DATA(int) _PyOS_opterr; 9 | PyAPI_DATA(int) _PyOS_optind; 10 | PyAPI_DATA(char *) _PyOS_optarg; 11 | 12 | PyAPI_FUNC(void) _PyOS_ResetGetOpt(void); 13 | PyAPI_FUNC(int) _PyOS_GetOpt(int argc, char **argv, char *optstring); 14 | 15 | #ifdef __cplusplus 16 | } 17 | #endif 18 | #endif /* !Py_PYGETOPT_H */ 19 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pystrcmp.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRCMP_H 2 | #define Py_STRCMP_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t); 9 | PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *); 10 | 11 | #if defined(MS_WINDOWS) || defined(PYOS_OS2) 12 | #define PyOS_strnicmp strnicmp 13 | #define PyOS_stricmp stricmp 14 | #else 15 | #define PyOS_strnicmp PyOS_mystrnicmp 16 | #define PyOS_stricmp PyOS_mystricmp 17 | #endif 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | 23 | #endif /* !Py_STRCMP_H */ 24 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pystrtod.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_STRTOD_H 2 | #define Py_STRTOD_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | 9 | PyAPI_FUNC(double) PyOS_ascii_strtod(const char *str, char **ptr); 10 | PyAPI_FUNC(double) PyOS_ascii_atof(const char *str); 11 | 12 | /* Deprecated in 2.7 and 3.1. Will disappear in 2.8 (if it exists) and 3.2 */ 13 | PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, size_t buf_len, 14 | const char *format, double d); 15 | PyAPI_FUNC(double) PyOS_string_to_double(const char *str, 16 | char **endptr, 17 | PyObject *overflow_exception); 18 | 19 | /* The caller is responsible for calling PyMem_Free to free the buffer 20 | that's is returned. */ 21 | PyAPI_FUNC(char *) PyOS_double_to_string(double val, 22 | char format_code, 23 | int precision, 24 | int flags, 25 | int *type); 26 | 27 | PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr); 28 | 29 | 30 | /* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */ 31 | #define Py_DTSF_SIGN 0x01 /* always add the sign */ 32 | #define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */ 33 | #define Py_DTSF_ALT 0x04 /* "alternate" formatting. it's format_code 34 | specific */ 35 | 36 | /* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */ 37 | #define Py_DTST_FINITE 0 38 | #define Py_DTST_INFINITE 1 39 | #define Py_DTST_NAN 2 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | 45 | #endif /* !Py_STRTOD_H */ 46 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/pythread.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_PYTHREAD_H 3 | #define Py_PYTHREAD_H 4 | 5 | typedef void *PyThread_type_lock; 6 | typedef void *PyThread_type_sema; 7 | 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | PyAPI_FUNC(void) PyThread_init_thread(void); 13 | PyAPI_FUNC(long) PyThread_start_new_thread(void (*)(void *), void *); 14 | PyAPI_FUNC(void) PyThread_exit_thread(void); 15 | PyAPI_FUNC(long) PyThread_get_thread_ident(void); 16 | 17 | PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void); 18 | PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock); 19 | PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); 20 | #define WAIT_LOCK 1 21 | #define NOWAIT_LOCK 0 22 | PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock); 23 | 24 | PyAPI_FUNC(size_t) PyThread_get_stacksize(void); 25 | PyAPI_FUNC(int) PyThread_set_stacksize(size_t); 26 | 27 | /* Thread Local Storage (TLS) API */ 28 | PyAPI_FUNC(int) PyThread_create_key(void); 29 | PyAPI_FUNC(void) PyThread_delete_key(int); 30 | PyAPI_FUNC(int) PyThread_set_key_value(int, void *); 31 | PyAPI_FUNC(void *) PyThread_get_key_value(int); 32 | PyAPI_FUNC(void) PyThread_delete_key_value(int key); 33 | 34 | /* Cleanup after a fork */ 35 | PyAPI_FUNC(void) PyThread_ReInitTLS(void); 36 | 37 | #ifdef __cplusplus 38 | } 39 | #endif 40 | 41 | #endif /* !Py_PYTHREAD_H */ 42 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/rangeobject.h: -------------------------------------------------------------------------------- 1 | 2 | /* Range object interface */ 3 | 4 | #ifndef Py_RANGEOBJECT_H 5 | #define Py_RANGEOBJECT_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | /* This is about the type 'xrange', not the built-in function range(), which 11 | returns regular lists. */ 12 | 13 | /* 14 | A range object represents an integer range. This is an immutable object; 15 | a range cannot change its value after creation. 16 | 17 | Range objects behave like the corresponding tuple objects except that 18 | they are represented by a start, stop, and step datamembers. 19 | */ 20 | 21 | PyAPI_DATA(PyTypeObject) PyRange_Type; 22 | 23 | #define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type) 24 | 25 | #ifdef __cplusplus 26 | } 27 | #endif 28 | #endif /* !Py_RANGEOBJECT_H */ 29 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/sliceobject.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_SLICEOBJECT_H 2 | #define Py_SLICEOBJECT_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | /* The unique ellipsis object "..." */ 8 | 9 | PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */ 10 | 11 | #define Py_Ellipsis (&_Py_EllipsisObject) 12 | 13 | /* Slice object interface */ 14 | 15 | /* 16 | 17 | A slice object containing start, stop, and step data members (the 18 | names are from range). After much talk with Guido, it was decided to 19 | let these be any arbitrary python type. Py_None stands for omitted values. 20 | */ 21 | 22 | typedef struct { 23 | PyObject_HEAD 24 | PyObject *start, *stop, *step; /* not NULL */ 25 | } PySliceObject; 26 | 27 | PyAPI_DATA(PyTypeObject) PySlice_Type; 28 | PyAPI_DATA(PyTypeObject) PyEllipsis_Type; 29 | 30 | #define PySlice_Check(op) (Py_TYPE(op) == &PySlice_Type) 31 | 32 | PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop, 33 | PyObject* step); 34 | PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop); 35 | PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, Py_ssize_t length, 36 | Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step); 37 | PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length, 38 | Py_ssize_t *start, Py_ssize_t *stop, 39 | Py_ssize_t *step, Py_ssize_t *slicelength); 40 | 41 | #ifdef __cplusplus 42 | } 43 | #endif 44 | #endif /* !Py_SLICEOBJECT_H */ 45 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/structseq.h: -------------------------------------------------------------------------------- 1 | 2 | /* Tuple object interface */ 3 | 4 | #ifndef Py_STRUCTSEQ_H 5 | #define Py_STRUCTSEQ_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct PyStructSequence_Field { 11 | char *name; 12 | char *doc; 13 | } PyStructSequence_Field; 14 | 15 | typedef struct PyStructSequence_Desc { 16 | char *name; 17 | char *doc; 18 | struct PyStructSequence_Field *fields; 19 | int n_in_sequence; 20 | } PyStructSequence_Desc; 21 | 22 | extern char* PyStructSequence_UnnamedField; 23 | 24 | PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type, 25 | PyStructSequence_Desc *desc); 26 | 27 | PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type); 28 | 29 | typedef struct { 30 | PyObject_VAR_HEAD 31 | PyObject *ob_item[1]; 32 | } PyStructSequence; 33 | 34 | /* Macro, *only* to be used to fill in brand new objects */ 35 | #define PyStructSequence_SET_ITEM(op, i, v) \ 36 | (((PyStructSequence *)(op))->ob_item[i] = v) 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | #endif /* !Py_STRUCTSEQ_H */ 42 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/sysmodule.h: -------------------------------------------------------------------------------- 1 | 2 | /* System module interface */ 3 | 4 | #ifndef Py_SYSMODULE_H 5 | #define Py_SYSMODULE_H 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | PyAPI_FUNC(PyObject *) PySys_GetObject(char *); 11 | PyAPI_FUNC(int) PySys_SetObject(char *, PyObject *); 12 | PyAPI_FUNC(FILE *) PySys_GetFile(char *, FILE *); 13 | PyAPI_FUNC(void) PySys_SetArgv(int, char **); 14 | PyAPI_FUNC(void) PySys_SetArgvEx(int, char **, int); 15 | PyAPI_FUNC(void) PySys_SetPath(char *); 16 | 17 | PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...) 18 | Py_GCC_ATTRIBUTE((format(printf, 1, 2))); 19 | PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...) 20 | Py_GCC_ATTRIBUTE((format(printf, 1, 2))); 21 | 22 | PyAPI_FUNC(void) PySys_ResetWarnOptions(void); 23 | PyAPI_FUNC(void) PySys_AddWarnOption(char *); 24 | PyAPI_FUNC(int) PySys_HasWarnOptions(void); 25 | 26 | PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | #endif /* !Py_SYSMODULE_H */ 32 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/timefuncs.h: -------------------------------------------------------------------------------- 1 | /* timefuncs.h 2 | */ 3 | 4 | /* Utility function related to timemodule.c. */ 5 | 6 | #ifndef TIMEFUNCS_H 7 | #define TIMEFUNCS_H 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | 12 | 13 | /* Cast double x to time_t, but raise ValueError if x is too large 14 | * to fit in a time_t. ValueError is set on return iff the return 15 | * value is (time_t)-1 and PyErr_Occurred(). 16 | */ 17 | PyAPI_FUNC(time_t) _PyTime_DoubleToTimet(double x); 18 | 19 | /* Get the current time since the epoch in seconds */ 20 | PyAPI_FUNC(double) _PyTime_FloatTime(void); 21 | 22 | 23 | #ifdef __cplusplus 24 | } 25 | #endif 26 | #endif /* TIMEFUNCS_H */ 27 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/traceback.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef Py_TRACEBACK_H 3 | #define Py_TRACEBACK_H 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | struct _frame; 9 | 10 | /* Traceback interface */ 11 | 12 | typedef struct _traceback { 13 | PyObject_HEAD 14 | struct _traceback *tb_next; 15 | struct _frame *tb_frame; 16 | int tb_lasti; 17 | int tb_lineno; 18 | } PyTracebackObject; 19 | 20 | PyAPI_FUNC(int) PyTraceBack_Here(struct _frame *); 21 | PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); 22 | PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, const char *, int, int); 23 | 24 | /* Reveal traceback type so we can typecheck traceback objects */ 25 | PyAPI_DATA(PyTypeObject) PyTraceBack_Type; 26 | #define PyTraceBack_Check(v) (Py_TYPE(v) == &PyTraceBack_Type) 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | #endif /* !Py_TRACEBACK_H */ 32 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/ucnhash.h: -------------------------------------------------------------------------------- 1 | /* Unicode name database interface */ 2 | 3 | #ifndef Py_UCNHASH_H 4 | #define Py_UCNHASH_H 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | /* revised ucnhash CAPI interface (exported through a "wrapper") */ 10 | 11 | #define PyUnicodeData_CAPSULE_NAME "unicodedata.ucnhash_CAPI" 12 | 13 | typedef struct { 14 | 15 | /* Size of this struct */ 16 | int size; 17 | 18 | /* Get name for a given character code. Returns non-zero if 19 | success, zero if not. Does not set Python exceptions. 20 | If self is NULL, data come from the default version of the database. 21 | If it is not NULL, it should be a unicodedata.ucd_X_Y_Z object */ 22 | int (*getname)(PyObject *self, Py_UCS4 code, char* buffer, int buflen); 23 | 24 | /* Get character code for a given name. Same error handling 25 | as for getname. */ 26 | int (*getcode)(PyObject *self, const char* name, int namelen, Py_UCS4* code); 27 | 28 | } _PyUnicode_Name_CAPI; 29 | 30 | #ifdef __cplusplus 31 | } 32 | #endif 33 | #endif /* !Py_UCNHASH_H */ 34 | -------------------------------------------------------------------------------- /src/scite/scite/python/include/warnings.h: -------------------------------------------------------------------------------- 1 | #ifndef Py_WARNINGS_H 2 | #define Py_WARNINGS_H 3 | #ifdef __cplusplus 4 | extern "C" { 5 | #endif 6 | 7 | PyAPI_FUNC(void) _PyWarnings_Init(void); 8 | 9 | PyAPI_FUNC(int) PyErr_WarnEx(PyObject *, const char *, Py_ssize_t); 10 | PyAPI_FUNC(int) PyErr_WarnExplicit(PyObject *, const char *, const char *, int, 11 | const char *, PyObject *); 12 | 13 | #define PyErr_WarnPy3k(msg, stacklevel) \ 14 | (Py_Py3kWarningFlag ? PyErr_WarnEx(PyExc_DeprecationWarning, msg, stacklevel) : 0) 15 | 16 | /* DEPRECATED: Use PyErr_WarnEx() instead. */ 17 | #define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1) 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | #endif /* !Py_WARNINGS_H */ 23 | 24 | -------------------------------------------------------------------------------- /src/scite/scite/python/libs.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/python/libs.zip -------------------------------------------------------------------------------- /src/scite/scite/scripts/CheckMentioned.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # CheckMentioned.py 3 | # Find all the symbols in scintilla/include/Scintilla.h and check if they 4 | # are mentioned in scintilla/doc/ScintillaDoc.html. 5 | # Requires Python 2.7 or later 6 | 7 | import string 8 | 9 | uninteresting = { 10 | "SCINTILLA_H", "SCI_START", "SCI_LEXER_START", "SCI_OPTIONAL_START", 11 | # These archaic names are #defined to the Sci_ prefixed modern equivalents. 12 | # They are not documented so they are not used in new code. 13 | "CharacterRange", "TextRange", "TextToFind", "RangeToFormat", 14 | } 15 | srcRoot = "../.." 16 | incFileName = srcRoot + "/scintilla/include/Scintilla.h" 17 | docFileName = srcRoot + "/scintilla/doc/ScintillaDoc.html" 18 | try: # Old Python 19 | identCharacters = "_" + string.letters + string.digits 20 | except AttributeError: # Python 3.x 21 | identCharacters = "_" + string.ascii_letters + string.digits 22 | 23 | # Convert all punctuation characters except '_' into spaces. 24 | def depunctuate(s): 25 | d = "" 26 | for ch in s: 27 | if ch in identCharacters: 28 | d = d + ch 29 | else: 30 | d = d + " " 31 | return d 32 | 33 | symbols = {} 34 | incFile = open(incFileName, "rt") 35 | for line in incFile.readlines(): 36 | if line.startswith("#define"): 37 | identifier = line.split()[1] 38 | symbols[identifier] = 0 39 | incFile.close() 40 | 41 | docFile = open(docFileName, "rt") 42 | for line in docFile.readlines(): 43 | for word in depunctuate(line).split(): 44 | if word in symbols.keys(): 45 | symbols[word] = 1 46 | docFile.close() 47 | 48 | identifiersSorted = list(symbols.keys()) 49 | identifiersSorted.sort() 50 | for identifier in identifiersSorted: 51 | if not symbols[identifier] and identifier not in uninteresting: 52 | print(identifier) 53 | -------------------------------------------------------------------------------- /src/scite/scite/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 | -------------------------------------------------------------------------------- /src/scite/scite/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 | @cd scintilla 5 | @call delbin 6 | @cd .. 7 | @cd scite 8 | @call delbin 9 | @cd .. 10 | -------------------------------------------------------------------------------- /src/scite/scite/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 | 5 | import os 6 | import shutil 7 | srcRoot = "../../" 8 | rpmRoot = "/usr/src/redhat/SOURCES/" 9 | rpmBin = "/usr/src/redhat/RPMS/i386/" 10 | rpmSource = "/usr/src/redhat/SRPMS/" 11 | 12 | verFileName = srcRoot + "scintilla/version.txt" 13 | vers = open(verFileName) 14 | #139 15 | vFull = vers.read().strip() 16 | vers.close() 17 | 18 | #1.39 19 | vPoint = vFull[0] + "." + vFull[1:] 20 | 21 | #1, 3, 9, 0 22 | vComma = vFull[0] + ", " + vFull[1] + ", " + vFull[2] + ", 0" 23 | 24 | print("[ %s | %s | %s ]" % (vFull, vPoint, vComma)) 25 | 26 | tgzV = "scite" + vFull + ".tgz" 27 | tgzFileName = srcRoot + "scite.tgz" 28 | tgzVFileName = srcRoot + tgzV 29 | 30 | print("[ %s | %s ]" % (tgzFileName, tgzVFileName)) 31 | 32 | if not os.access(tgzFileName, os.F_OK): 33 | print("Base file '" + tgzFileName + "' does not exist.") 34 | else: 35 | shutil.copyfile(tgzFileName, tgzVFileName) 36 | os.unlink(tgzFileName) 37 | 38 | rpmVFileName = rpmRoot + tgzV 39 | 40 | shutil.copyfile(tgzVFileName, rpmVFileName) 41 | 42 | # Run the rpm build command 43 | os.system("rpm -ba scite.spec") 44 | 45 | rpmB = "scite-" + vPoint + "-1.i386.rpm" 46 | shutil.copyfile(rpmBin + rpmB, srcRoot + rpmB) 47 | rpmS = "scite-" + vPoint + "-1.src.rpm" 48 | shutil.copyfile(rpmSource + rpmS, srcRoot + rpmS) 49 | 50 | -------------------------------------------------------------------------------- /src/scite/scite/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 | // Related to Utf8_16::encodingType but with additional values at end 9 | enum UniMode { 10 | uni8Bit = 0, uni16BE = 1, uni16LE = 2, uniUTF8 = 3, 11 | uniCookie = 4 12 | }; 13 | 14 | std::string ExtractLine(const char *buf, size_t length); 15 | UniMode CodingCookieValue(const char *buf, size_t length); 16 | -------------------------------------------------------------------------------- /src/scite/scite/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 | class LuaExtension : public Extension { 7 | private: 8 | LuaExtension(); // Singleton 9 | LuaExtension(const LuaExtension &); // Disable copy ctor 10 | void operator=(const LuaExtension &); // Disable operator= 11 | 12 | public: 13 | static LuaExtension &Instance(); 14 | 15 | virtual ~LuaExtension(); 16 | 17 | virtual bool Initialise(ExtensionAPI *host_); 18 | virtual bool Finalise(); 19 | virtual bool Clear(); 20 | virtual bool Load(const char *filename); 21 | 22 | virtual bool InitBuffer(int); 23 | virtual bool ActivateBuffer(int); 24 | virtual bool RemoveBuffer(int); 25 | 26 | virtual bool OnOpen(const char *filename); 27 | virtual bool OnSwitchFile(const char *filename); 28 | virtual bool OnBeforeSave(const char *filename); 29 | virtual bool OnSave(const char *filename); 30 | virtual bool OnChar(char ch); 31 | virtual bool OnExecute(const char *s); 32 | virtual bool OnSavePointReached(); 33 | virtual bool OnSavePointLeft(); 34 | virtual bool OnStyle(unsigned int startPos, int lengthDoc, int initStyle, StyleWriter *styler); 35 | virtual bool OnDoubleClick(); 36 | virtual bool OnUpdateUI(); 37 | virtual bool OnMarginClick(); 38 | virtual bool OnUserListSelection(int listType, const char *selection); 39 | virtual bool OnKey(int keyval, int modifiers); 40 | virtual bool OnDwellStart(int pos, const char *word); 41 | virtual bool OnClose(const char *filename); 42 | virtual bool OnUserStrip(int control, int change); 43 | virtual bool NeedsOnClose(); 44 | }; 45 | -------------------------------------------------------------------------------- /src/scite/scite/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 | struct LineRange { 9 | int lineStart; 10 | int lineEnd; 11 | LineRange(int lineStart_, int lineEnd_) : lineStart(lineStart_), lineEnd(lineEnd_) {} 12 | }; 13 | 14 | std::vector LinesBreak(GUI::ScintillaWindow *pSci); 15 | 16 | class MatchMarker { 17 | GUI::ScintillaWindow *pSci; 18 | std::string textMatch; 19 | int styleMatch; 20 | int flagsMatch; 21 | int indicator; 22 | int bookMark; 23 | std::vector lineRanges; 24 | public: 25 | MatchMarker(); 26 | ~MatchMarker(); 27 | void StartMatch(GUI::ScintillaWindow *pSci_, 28 | std::string textMatch_, int flagsMatch_, int styleMatch_, 29 | int indicator_, int bookMark_); 30 | bool Complete() const; 31 | void Continue(); 32 | void Stop(); 33 | }; 34 | -------------------------------------------------------------------------------- /src/scite/scite/src/Mutex.h: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file Mutex.h 3 | ** Define mutex 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 MUTEX_H 12 | #define MUTEX_H 13 | 14 | class Mutex { 15 | public: 16 | virtual void Lock() = 0; 17 | virtual void Unlock() = 0; 18 | virtual ~Mutex() {} 19 | static Mutex *Create(); 20 | }; 21 | 22 | class Lock { 23 | Mutex *mute; 24 | public: 25 | explicit Lock(Mutex *mute_) : mute(mute_) { 26 | mute->Lock(); 27 | } 28 | ~Lock() { 29 | mute->Unlock(); 30 | } 31 | }; 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /src/scite/scite/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(const char *mnemonic); 14 | static bool MatchKeyCode(long parsedKeyCode, int key, int modifiers); 15 | }; 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/scite/scite/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 | class StringList { 9 | // Text pointed into by words and wordsNoCase 10 | std::string listText; 11 | // Each word contains at least one character. 12 | std::vector words; 13 | std::vector wordsNoCase; 14 | bool onlyLineEnds; ///< Delimited by any white space or only line ends 15 | bool sorted; 16 | bool sortedNoCase; 17 | void SetFromListText(); 18 | void SortIfNeeded(bool ignoreCase); 19 | public: 20 | explicit StringList(bool onlyLineEnds_ = false) : 21 | words(0), wordsNoCase(0), onlyLineEnds(onlyLineEnds_), 22 | sorted(false), sortedNoCase(false) {} 23 | ~StringList() { Clear(); } 24 | size_t Length() const { return words.size(); } 25 | operator bool() const { return !words.empty(); } 26 | char *operator[](size_t ind) { return words[ind]; } 27 | void Clear(); 28 | void Set(const char *s); 29 | void Set(const std::vector &data); 30 | std::string GetNearestWord(const char *wordStart, size_t searchLen, 31 | bool ignoreCase, const std::string &wordCharacters, int wordIndex); 32 | std::string GetNearestWords(const char *wordStart, size_t searchLen, 33 | bool ignoreCase, char otherSeparator='\0', bool exactLen=false); 34 | }; 35 | -------------------------------------------------------------------------------- /src/scite/scite/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 | class StyleDefinition { 9 | public: 10 | std::string font; 11 | float sizeFractional; 12 | int size; 13 | std::string fore; 14 | std::string back; 15 | int weight; 16 | bool italics; 17 | bool eolfilled; 18 | bool underlined; 19 | int caseForce; 20 | bool visible; 21 | bool changeable; 22 | enum flags { sdNone = 0, sdFont = 0x1, sdSize = 0x2, sdFore = 0x4, sdBack = 0x8, 23 | sdWeight = 0x10, sdItalics = 0x20, sdEOLFilled = 0x40, sdUnderlined = 0x80, 24 | sdCaseForce = 0x100, sdVisible = 0x200, sdChangeable = 0x400} specified; 25 | StyleDefinition(const char *definition); 26 | bool ParseStyleDefinition(const char *definition); 27 | long ForeAsLong() const; 28 | long BackAsLong() const; 29 | int FractionalSize() const; 30 | bool IsBold() const; 31 | }; 32 | 33 | typedef long Colour; 34 | 35 | inline Colour ColourRGB(unsigned int red, unsigned int green, unsigned int blue) { 36 | return red | (green << 8) | (blue << 16); 37 | } 38 | 39 | int IntFromHexDigit(int ch); 40 | int IntFromHexByte(const char *hexByte); 41 | 42 | Colour ColourFromString(const std::string &s); 43 | 44 | struct IndicatorDefinition { 45 | int style; 46 | long colour; 47 | int fillAlpha; 48 | int outlineAlpha; 49 | bool under; 50 | IndicatorDefinition(const char *definition); 51 | bool ParseIndicatorDefinition(const char *definition); 52 | }; 53 | -------------------------------------------------------------------------------- /src/scite/scite/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 | struct Worker { 9 | private: 10 | Mutex *mutex; 11 | volatile bool completed; 12 | volatile bool cancelling; 13 | volatile int jobSize; 14 | volatile int jobProgress; 15 | public: 16 | Worker() : mutex(Mutex::Create()), completed(false), cancelling(false), jobSize(1), jobProgress(0) { 17 | } 18 | virtual ~Worker() { 19 | delete mutex; 20 | } 21 | virtual void Execute() {} 22 | bool FinishedJob() const { 23 | Lock lock(mutex); 24 | return completed; 25 | } 26 | void SetCompleted() { 27 | Lock lock(mutex); 28 | completed = true; 29 | } 30 | bool Cancelling() const { 31 | Lock lock(mutex); 32 | return cancelling; 33 | } 34 | int SizeJob() const { 35 | Lock lock(mutex); 36 | return jobSize; 37 | } 38 | void SetSizeJob(int size) { 39 | Lock lock(mutex); 40 | jobSize = size; 41 | } 42 | int ProgressMade() const { 43 | Lock lock(mutex); 44 | return jobProgress; 45 | } 46 | void IncrementProgress(int increment) { 47 | Lock lock(mutex); 48 | jobProgress += increment; 49 | } 50 | virtual void Cancel() { 51 | { 52 | Lock lock(mutex); 53 | cancelling = true; 54 | } 55 | // Wait for writing thread to finish 56 | for (;;) { 57 | Lock lock(mutex); 58 | if (completed) 59 | return; 60 | } 61 | } 62 | }; 63 | 64 | struct WorkerListener { 65 | virtual void PostOnMainThread(int cmd, Worker *pWorker) = 0; 66 | }; 67 | -------------------------------------------------------------------------------- /src/scite/scite/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 | /* Modifications for Windows to allow UTF-8 file names and command lines */ 9 | /* 10 | Imported into Lua build with -DLUA_USER_H=\"scite_lua_win.h\" 11 | Redirect fopen and _popen to functions that treat their arguments as UTF-8. 12 | If UTF-8 does not work then retry with the original strings as may be in locale characters. 13 | */ 14 | #if defined(LUA_WIN) 15 | #include 16 | FILE *scite_lua_fopen(const char *filename, const char *mode); 17 | #define fopen scite_lua_fopen 18 | FILE *scite_lua_popen(const char *filename, const char *mode); 19 | #define _popen scite_lua_popen 20 | #endif 21 | -------------------------------------------------------------------------------- /src/scite/scite/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 | class DirectorExtension : public Extension { 9 | private: 10 | ExtensionAPI *host; 11 | DirectorExtension() : host(0) {} // Singleton 12 | DirectorExtension(const DirectorExtension &); // Disable copy ctor 13 | void operator=(const DirectorExtension &); // Disable operator= 14 | 15 | public: 16 | static DirectorExtension &Instance(); 17 | 18 | // Implement the Extension interface 19 | virtual bool Initialise(ExtensionAPI *host_); 20 | virtual bool Finalise(); 21 | virtual bool Clear(); 22 | virtual bool Load(const char *filename); 23 | 24 | virtual bool OnOpen(const char *path); 25 | virtual bool OnSwitchFile(const char *path); 26 | virtual bool OnSave(const char *path); 27 | virtual bool OnChar(char ch); 28 | virtual bool OnExecute(const char *s); 29 | virtual bool OnSavePointReached(); 30 | virtual bool OnSavePointLeft(); 31 | virtual bool OnStyle(unsigned int startPos, int lengthDoc, int initStyle, StyleWriter *styler); 32 | virtual bool OnDoubleClick(); 33 | virtual bool OnUpdateUI(); 34 | virtual bool OnMarginClick(); 35 | virtual bool OnMacro(const char *command, const char *params); 36 | 37 | virtual bool SendProperty(const char *prop); 38 | virtual bool OnClose(const char *path); 39 | virtual bool NeedsOnClose(); 40 | 41 | // Allow messages through to extension 42 | void HandleStringMessage(const char *message); 43 | }; 44 | 45 | -------------------------------------------------------------------------------- /src/scite/scite/win32/DragDrop.cur: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/DragDrop.cur -------------------------------------------------------------------------------- /src/scite/scite/win32/SciBall.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/SciBall.ico -------------------------------------------------------------------------------- /src/scite/scite/win32/SciTE.exe.manifest: -------------------------------------------------------------------------------- 1 | 2 | 4 | 10 | SciTE 11 | 12 | 13 | true 14 | 15 | 16 | 17 | 18 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /src/scite/scite/win32/WinMutex.cxx: -------------------------------------------------------------------------------- 1 | // SciTE - Scintilla based Text Editor 2 | /** @file WinMutex.cxx 3 | ** Define mutex 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 | // http://www.microsoft.com/msj/0797/win320797.aspx 10 | 11 | #include 12 | #include "Mutex.h" 13 | 14 | class WinMutex : public Mutex { 15 | private: 16 | CRITICAL_SECTION cs; 17 | virtual void Lock() { ::EnterCriticalSection(&cs); } 18 | virtual void Unlock() { ::LeaveCriticalSection(&cs); } 19 | WinMutex() { ::InitializeCriticalSection(&cs); } 20 | virtual ~WinMutex() { ::DeleteCriticalSection(&cs); } 21 | friend class Mutex; 22 | }; 23 | 24 | Mutex *Mutex::Create() { 25 | return new WinMutex(); 26 | } 27 | -------------------------------------------------------------------------------- /src/scite/scite/win32/around.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/around.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/around20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/around20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/around24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/around24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/around32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/around32.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/backslash.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/backslash.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/backslash20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/backslash20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/backslash24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/backslash24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/backslash32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/backslash32.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/case.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/case.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/case20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/case20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/case24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/case24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/case32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/case32.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/closefile.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/closefile.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/regex.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/regex.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/regex20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/regex20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/regex24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/regex24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/regex32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/regex32.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/up.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/up.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/up20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/up20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/up24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/up24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/up32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/up32.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/word.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/word.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/word20.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/word20.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/word24.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/word24.bmp -------------------------------------------------------------------------------- /src/scite/scite/win32/word32.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/moltenform/scite-with-python/4b441d409a0d09040507e2aa93d6655851dd0166/src/scite/scite/win32/word32.bmp --------------------------------------------------------------------------------