[geany/geany] 68b6a3: Update to Scintilla 5.5.4 and Lexilla 5.4.2

Branch: refs/heads/master Author: Jiří Techet techet@gmail.com Committer: Jiří Techet techet@gmail.com Date: Fri, 20 Dec 2024 21:39:09 UTC Commit: 68b6a36f9d0f692cb40806ebce3e9ed9e49251f2 https://github.com/geany/geany/commit/68b6a36f9d0f692cb40806ebce3e9ed9e49251...

Log Message: ----------- Update to Scintilla 5.5.4 and Lexilla 5.4.2

Modified Paths: -------------- meson.build scintilla/Makefile.am scintilla/gtk/PlatGTK.cxx scintilla/gtk/ScintillaGTK.cxx scintilla/gtk/ScintillaGTK.h scintilla/include/ILoader.h scintilla/include/Scintilla.h scintilla/include/Scintilla.iface scintilla/include/ScintillaCall.h scintilla/include/ScintillaMessages.h scintilla/include/ScintillaTypes.h scintilla/lexilla/include/Lexilla.h scintilla/lexilla/include/SciLexer.h scintilla/lexilla/lexers/LexAU3.cxx scintilla/lexilla/lexers/LexAbaqus.cxx scintilla/lexilla/lexers/LexAda.cxx scintilla/lexilla/lexers/LexAsciidoc.cxx scintilla/lexilla/lexers/LexAsm.cxx scintilla/lexilla/lexers/LexBash.cxx scintilla/lexilla/lexers/LexBasic.cxx scintilla/lexilla/lexers/LexBatch.cxx scintilla/lexilla/lexers/LexCIL.cxx scintilla/lexilla/lexers/LexCOBOL.cxx scintilla/lexilla/lexers/LexCPP.cxx scintilla/lexilla/lexers/LexCSS.cxx scintilla/lexilla/lexers/LexCaml.cxx scintilla/lexilla/lexers/LexCmake.cxx scintilla/lexilla/lexers/LexCoffeeScript.cxx scintilla/lexilla/lexers/LexD.cxx scintilla/lexilla/lexers/LexDart.cxx scintilla/lexilla/lexers/LexDiff.cxx scintilla/lexilla/lexers/LexErlang.cxx scintilla/lexilla/lexers/LexForth.cxx scintilla/lexilla/lexers/LexFortran.cxx scintilla/lexilla/lexers/LexGDScript.cxx scintilla/lexilla/lexers/LexHTML.cxx scintilla/lexilla/lexers/LexHaskell.cxx scintilla/lexilla/lexers/LexJulia.cxx scintilla/lexilla/lexers/LexLaTeX.cxx scintilla/lexilla/lexers/LexLisp.cxx scintilla/lexilla/lexers/LexLua.cxx scintilla/lexilla/lexers/LexMake.cxx scintilla/lexilla/lexers/LexMarkdown.cxx scintilla/lexilla/lexers/LexMatlab.cxx scintilla/lexilla/lexers/LexNim.cxx scintilla/lexilla/lexers/LexNsis.cxx scintilla/lexilla/lexers/LexNull.cxx scintilla/lexilla/lexers/LexPO.cxx scintilla/lexilla/lexers/LexPascal.cxx scintilla/lexilla/lexers/LexPerl.cxx scintilla/lexilla/lexers/LexPowerShell.cxx scintilla/lexilla/lexers/LexProps.cxx scintilla/lexilla/lexers/LexPython.cxx scintilla/lexilla/lexers/LexR.cxx scintilla/lexilla/lexers/LexRaku.cxx scintilla/lexilla/lexers/LexRuby.cxx scintilla/lexilla/lexers/LexRust.cxx scintilla/lexilla/lexers/LexSQL.cxx scintilla/lexilla/lexers/LexSmalltalk.cxx scintilla/lexilla/lexers/LexTCL.cxx scintilla/lexilla/lexers/LexTxt2tags.cxx scintilla/lexilla/lexers/LexVHDL.cxx scintilla/lexilla/lexers/LexVerilog.cxx scintilla/lexilla/lexers/LexVisualProlog.cxx scintilla/lexilla/lexers/LexYAML.cxx scintilla/lexilla/lexers/LexZig.cxx scintilla/lexilla/lexlib/CatalogueModules.h scintilla/lexilla/lexlib/CharacterCategory.cxx scintilla/lexilla/lexlib/CharacterCategory.h scintilla/lexilla/lexlib/CharacterSet.cxx scintilla/lexilla/lexlib/CharacterSet.h scintilla/lexilla/lexlib/InList.cxx scintilla/lexilla/lexlib/InList.h scintilla/lexilla/lexlib/LexAccessor.cxx scintilla/lexilla/lexlib/LexAccessor.h scintilla/lexilla/lexlib/LexerSimple.cxx scintilla/lexilla/lexlib/LexerSimple.h scintilla/lexilla/lexlib/OptionSet.h scintilla/lexilla/lexlib/SparseState.h scintilla/lexilla/lexlib/StyleContext.cxx scintilla/lexilla/lexlib/StyleContext.h scintilla/lexilla/lexlib/SubStyles.h scintilla/lexilla/lexlib/WordList.cxx scintilla/lexilla/lexlib/WordList.h scintilla/lexilla/src/Lexilla.cxx scintilla/lexilla/version.txt scintilla/src/AutoComplete.cxx scintilla/src/AutoComplete.h scintilla/src/CallTip.cxx scintilla/src/CallTip.h scintilla/src/CellBuffer.cxx scintilla/src/CellBuffer.h scintilla/src/ChangeHistory.cxx scintilla/src/ChangeHistory.h scintilla/src/CharacterCategoryMap.cxx scintilla/src/CharacterCategoryMap.h scintilla/src/Decoration.cxx scintilla/src/Document.cxx scintilla/src/Document.h scintilla/src/EditModel.cxx scintilla/src/EditModel.h scintilla/src/EditView.cxx scintilla/src/Editor.cxx scintilla/src/Editor.h scintilla/src/Geometry.h scintilla/src/Indicator.cxx scintilla/src/Indicator.h scintilla/src/KeyMap.cxx scintilla/src/LineMarker.cxx scintilla/src/LineMarker.h scintilla/src/MarginView.cxx scintilla/src/Partitioning.h scintilla/src/PerLine.cxx scintilla/src/Platform.h scintilla/src/PositionCache.cxx scintilla/src/PositionCache.h scintilla/src/RESearch.cxx scintilla/src/RESearch.h scintilla/src/RunStyles.cxx scintilla/src/ScintillaBase.cxx scintilla/src/ScintillaBase.h scintilla/src/Selection.cxx scintilla/src/Selection.h scintilla/src/SparseVector.h scintilla/src/Style.cxx scintilla/src/Style.h scintilla/src/UndoHistory.cxx scintilla/src/UndoHistory.h scintilla/src/UniConversion.cxx scintilla/src/UniConversion.h scintilla/src/ViewStyle.cxx scintilla/src/ViewStyle.h scintilla/src/XPM.cxx scintilla/version.txt

Modified: meson.build 4 lines changed, 4 insertions(+), 0 deletions(-) =================================================================== @@ -305,6 +305,8 @@ lexilla = static_library('lexilla', 'scintilla/lexilla/lexlib/CharacterSet.h', 'scintilla/lexilla/lexlib/DefaultLexer.cxx', 'scintilla/lexilla/lexlib/DefaultLexer.h', + 'scintilla/lexilla/lexlib/InList.cxx', + 'scintilla/lexilla/lexlib/InList.h', 'scintilla/lexilla/lexlib/LexAccessor.cxx', 'scintilla/lexilla/lexlib/LexAccessor.h', 'scintilla/lexilla/lexlib/LexerBase.cxx', @@ -421,6 +423,8 @@ scintilla = static_library('scintilla', 'scintilla/src/SplitVector.h', 'scintilla/src/Style.cxx', 'scintilla/src/Style.h', + 'scintilla/src/UndoHistory.cxx', + 'scintilla/src/UndoHistory.h', 'scintilla/src/UniConversion.cxx', 'scintilla/src/UniConversion.h', 'scintilla/src/UniqueString.cxx',

Modified: scintilla/Makefile.am 4 lines changed, 4 insertions(+), 0 deletions(-) =================================================================== @@ -79,6 +79,8 @@ lexilla/lexlib/CharacterSet.cxx \ lexilla/lexlib/CharacterSet.h \ lexilla/lexlib/DefaultLexer.cxx \ lexilla/lexlib/DefaultLexer.h \ +lexilla/lexlib/InList.cxx \ +lexilla/lexlib/InList.h \ lexilla/lexlib/LexAccessor.cxx \ lexilla/lexlib/LexAccessor.h \ lexilla/lexlib/LexerBase.cxx \ @@ -182,6 +184,8 @@ src/SparseVector.h \ src/SplitVector.h \ src/Style.cxx \ src/Style.h \ +src/UndoHistory.cxx \ +src/UndoHistory.h \ src/UniConversion.cxx \ src/UniConversion.h \ src/UniqueString.cxx \

Modified: scintilla/gtk/PlatGTK.cxx 30 lines changed, 28 insertions(+), 2 deletions(-) =================================================================== @@ -5,6 +5,7 @@

#include <cstddef> #include <cstdlib> +#include <cstdint> #include <cstring> #include <cstdio> #include <cmath> @@ -36,6 +37,7 @@

#include "Scintilla.h" #include "ScintillaWidget.h" +#include "CharacterType.h" #include "XPM.h" #include "UniConversion.h"

@@ -99,6 +101,8 @@ class FontHandle : public Font { pango_font_description_set_size(fd.get(), pango_units_from_double(fp.size)); pango_font_description_set_weight(fd.get(), static_cast<PangoWeight>(fp.weight)); pango_font_description_set_style(fd.get(), fp.italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); + pango_font_description_set_stretch(fd.get(), + static_cast<PangoStretch>(static_cast<int>(fp.stretch)-1)); } } ~FontHandle() override = default; @@ -1085,6 +1089,27 @@ void SurfaceImpl::MeasureWidthsUTF8(const Font *font_, std::string_view text, XY } while (!iti.finished) { iti.Next(); + if (iti.curIndex < i) { + // Backwards movement indicater bidirectional. + // Divide into ASCII prefix and non-ASCII suffix as this is common case + // and produces accurate positions for the ASCII prefix. + size_t lenASCII=0; + while (lenASCII<text.length() && IsASCII(text[lenASCII])) { + lenASCII++; + } + const std::string_view asciiPrefix = text.substr(0, lenASCII); + const std::string_view bidiSuffix = text.substr(lenASCII); + // Recurse for ASCII prefix. + MeasureWidthsUTF8(font_, asciiPrefix, positions); + // Measure the whole bidiSuffix and spread its width evenly + const XYPOSITION endASCII = positions[lenASCII-1]; + const XYPOSITION widthBidi = WidthText(font_, bidiSuffix); + const XYPOSITION widthByteBidi = widthBidi / bidiSuffix.length(); + for (size_t bidiPos=0; bidiPos<bidiSuffix.length(); bidiPos++) { + positions[bidiPos+lenASCII] = endASCII + widthByteBidi * (bidiPos + 1); + } + return; + } const int places = iti.curIndex - i; while (i < iti.curIndex) { // Evenly distribute space among bytes of this cluster. @@ -1331,7 +1356,8 @@ void Window::SetCursor(Cursor curs) {

if (WindowFromWidget(PWidget(wid))) gdk_window_set_cursor(WindowFromWidget(PWidget(wid)), gdkCurs); - UnRefCursor(gdkCurs); + if (gdkCurs) + UnRefCursor(gdkCurs); }

/* Returns rectangle of monitor pt is on, both rect and pt are in Window's @@ -2149,7 +2175,7 @@ ColourRGBA Platform::Chrome() { }

ColourRGBA Platform::ChromeHighlight() { - return ColourRGBA(0xff, 0xff, 0xff); + return white; }

const char *Platform::DefaultFont() {

Modified: scintilla/gtk/ScintillaGTK.cxx 14 lines changed, 7 insertions(+), 7 deletions(-) =================================================================== @@ -704,10 +704,11 @@ void ScintillaGTK::Init() { timers[tr].reason = static_cast<TickReason>(tr); timers[tr].scintilla = this; } - vs.indicators[SC_INDICATOR_UNKNOWN] = Indicator(IndicatorStyle::Hidden, ColourRGBA(0, 0, 0xff)); - vs.indicators[SC_INDICATOR_INPUT] = Indicator(IndicatorStyle::Dots, ColourRGBA(0, 0, 0xff)); - vs.indicators[SC_INDICATOR_CONVERTED] = Indicator(IndicatorStyle::CompositionThick, ColourRGBA(0, 0, 0xff)); - vs.indicators[SC_INDICATOR_TARGET] = Indicator(IndicatorStyle::StraightBox, ColourRGBA(0, 0, 0xff)); + + vs.indicators[SC_INDICATOR_UNKNOWN] = Indicator(IndicatorStyle::Hidden, colourIME); + vs.indicators[SC_INDICATOR_INPUT] = Indicator(IndicatorStyle::Dots, colourIME); + vs.indicators[SC_INDICATOR_CONVERTED] = Indicator(IndicatorStyle::CompositionThick, colourIME); + vs.indicators[SC_INDICATOR_TARGET] = Indicator(IndicatorStyle::StraightBox, colourIME);

fontOptionsPrevious = FontOptions(PWidget(wText)); } @@ -1501,8 +1502,8 @@ void ScintillaGTK::PrimaryClearSelection(GtkClipboard *clip, gpointer pSci) { void ScintillaGTK::ClaimSelection() { // X Windows has a 'primary selection' as well as the clipboard. // Whenever the user selects some text, we become the primary selection - ClearPrimarySelection(); if (!sel.Empty()) { + ClearPrimarySelection(); if (gtk_clipboard_set_with_data( gtk_clipboard_get(GDK_SELECTION_PRIMARY), clipboardCopyTargets, nClipboardCopyTargets, @@ -2378,8 +2379,7 @@ void ScintillaGTK::MoveImeCarets(Sci::Position pos) { // Move carets relatively by bytes for (size_t r=0; r<sel.Count(); r++) { const Sci::Position positionInsert = sel.Range(r).Start().Position(); - sel.Range(r).caret.SetPosition(positionInsert + pos); - sel.Range(r).anchor.SetPosition(positionInsert + pos); + sel.Range(r) = SelectionRange(positionInsert + pos); } }

Modified: scintilla/gtk/ScintillaGTK.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -293,7 +293,7 @@ class ScintillaGTK : public ScintillaBase { class GObjectWatcher { GObject *weakRef;

- void WeakNotifyThis(GObject *obj G_GNUC_UNUSED) { + void WeakNotifyThis([[maybe_unused]] GObject *obj) { PLATFORM_ASSERT(obj == weakRef);

Destroyed();

Modified: scintilla/include/ILoader.h 13 lines changed, 13 insertions(+), 0 deletions(-) =================================================================== @@ -1,6 +1,7 @@ // Scintilla source code edit control /** @file ILoader.h ** Interface for loading into a Scintilla document from a background thread. + ** Interface for manipulating a document without a view. **/ // Copyright 1998-2017 by Neil Hodgson neilh@scintilla.org // The License.txt file describes the conditions under which this software may be distributed. @@ -20,6 +21,18 @@ class ILoader { virtual void * SCI_METHOD ConvertToDocument() = 0; };

+static constexpr int deRelease0 = 0; + +class IDocumentEditable { +public: + // Allow this interface to add methods over time and discover whether new methods available. + virtual int SCI_METHOD DEVersion() const noexcept = 0; + + // Lifetime control + virtual int SCI_METHOD AddRef() noexcept = 0; + virtual int SCI_METHOD Release() = 0; +}; + }

#endif

Modified: scintilla/include/Scintilla.h 42 lines changed, 41 insertions(+), 1 deletions(-) =================================================================== @@ -166,6 +166,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SC_MARKNUM_FOLDERSUB 29 #define SC_MARKNUM_FOLDER 30 #define SC_MARKNUM_FOLDEROPEN 31 +#define SC_MASK_HISTORY 0x01E00000 #define SC_MASK_FOLDERS 0xFE000000 #define SCI_MARKERDEFINE 2040 #define SCI_MARKERSETFORE 2041 @@ -281,6 +282,17 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_STYLESETHOTSPOT 2409 #define SCI_STYLESETCHECKMONOSPACED 2254 #define SCI_STYLEGETCHECKMONOSPACED 2255 +#define SC_STRETCH_ULTRA_CONDENSED 1 +#define SC_STRETCH_EXTRA_CONDENSED 2 +#define SC_STRETCH_CONDENSED 3 +#define SC_STRETCH_SEMI_CONDENSED 4 +#define SC_STRETCH_NORMAL 5 +#define SC_STRETCH_SEMI_EXPANDED 6 +#define SC_STRETCH_EXPANDED 7 +#define SC_STRETCH_EXTRA_EXPANDED 8 +#define SC_STRETCH_ULTRA_EXPANDED 9 +#define SCI_STYLESETSTRETCH 2258 +#define SCI_STYLEGETSTRETCH 2259 #define SCI_STYLESETINVISIBLEREPRESENTATION 2256 #define SCI_STYLEGETINVISIBLEREPRESENTATION 2257 #define SC_ELEMENT_LIST 0 @@ -295,6 +307,8 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SC_ELEMENT_SELECTION_SECONDARY_BACK 15 #define SC_ELEMENT_SELECTION_INACTIVE_TEXT 16 #define SC_ELEMENT_SELECTION_INACTIVE_BACK 17 +#define SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_TEXT 18 +#define SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_BACK 19 #define SC_ELEMENT_CARET 40 #define SC_ELEMENT_CARET_ADDITIONAL 41 #define SC_ELEMENT_CARET_LINE_BACK 50 @@ -339,6 +353,21 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_GETCHARACTERCATEGORYOPTIMIZATION 2721 #define SCI_BEGINUNDOACTION 2078 #define SCI_ENDUNDOACTION 2079 +#define SCI_GETUNDOSEQUENCE 2799 +#define SCI_GETUNDOACTIONS 2790 +#define SCI_SETUNDOSAVEPOINT 2791 +#define SCI_GETUNDOSAVEPOINT 2792 +#define SCI_SETUNDODETACH 2793 +#define SCI_GETUNDODETACH 2794 +#define SCI_SETUNDOTENTATIVE 2795 +#define SCI_GETUNDOTENTATIVE 2796 +#define SCI_SETUNDOCURRENT 2797 +#define SCI_GETUNDOCURRENT 2798 +#define SCI_PUSHUNDOACTIONTYPE 2800 +#define SCI_CHANGELASTUNDOACTIONTEXT 2801 +#define SCI_GETUNDOACTIONTYPE 2802 +#define SCI_GETUNDOACTIONPOSITION 2803 +#define SCI_GETUNDOACTIONTEXT 2804 #define INDIC_PLAIN 0 #define INDIC_SQUIGGLE 1 #define INDIC_TT 2 @@ -431,6 +460,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_AUTOCGETAUTOHIDE 2119 #define SC_AUTOCOMPLETE_NORMAL 0 #define SC_AUTOCOMPLETE_FIXED_SIZE 1 +#define SC_AUTOCOMPLETE_SELECT_FIRST_ITEM 2 #define SCI_AUTOCSETOPTIONS 2638 #define SCI_AUTOCGETOPTIONS 2639 #define SCI_AUTOCSETDROPRESTOFWORD 2270 @@ -443,6 +473,8 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_AUTOCGETMAXWIDTH 2209 #define SCI_AUTOCSETMAXHEIGHT 2210 #define SCI_AUTOCGETMAXHEIGHT 2211 +#define SCI_AUTOCSETSTYLE 2109 +#define SCI_AUTOCGETSTYLE 2120 #define SCI_SETINDENT 2122 #define SCI_GETINDENT 2123 #define SCI_SETUSETABS 2124 @@ -735,7 +767,9 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_CANCEL 2325 #define SCI_DELETEBACK 2326 #define SCI_TAB 2327 +#define SCI_LINEINDENT 2813 #define SCI_BACKTAB 2328 +#define SCI_LINEDEDENT 2814 #define SCI_NEWLINE 2329 #define SCI_FORMFEED 2330 #define SCI_VCHOME 2331 @@ -874,7 +908,9 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SC_SEL_LINES 2 #define SC_SEL_THIN 3 #define SCI_SETSELECTIONMODE 2422 +#define SCI_CHANGESELECTIONMODE 2659 #define SCI_GETSELECTIONMODE 2423 +#define SCI_SETMOVEEXTENDSSELECTION 2719 #define SCI_GETMOVEEXTENDSSELECTION 2706 #define SCI_GETLINESELSTARTPOSITION 2424 #define SCI_GETLINESELENDPOSITION 2425 @@ -957,6 +993,9 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_SETLAYOUTTHREADS 2775 #define SCI_GETLAYOUTTHREADS 2776 #define SCI_COPYALLOWLINE 2519 +#define SCI_CUTALLOWLINE 2810 +#define SCI_SETCOPYSEPARATOR 2811 +#define SCI_GETCOPYSEPARATOR 2812 #define SCI_GETCHARACTERPOINTER 2520 #define SCI_GETRANGEPOINTER 2643 #define SCI_GETGAPPOSITION 2644 @@ -1020,6 +1059,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP #define SCI_CLEARSELECTIONS 2571 #define SCI_SETSELECTION 2572 #define SCI_ADDSELECTION 2573 +#define SCI_SELECTIONFROMPOINT 2474 #define SCI_DROPSELECTIONN 2671 #define SCI_SETMAINSELECTION 2574 #define SCI_GETMAINSELECTION 2575 @@ -1354,7 +1394,7 @@ struct Sci_RangeToFormatFull {

#ifndef __cplusplus /* For the GTK+ platform, g-ir-scanner needs to have these typedefs. This - * is not required in C++ code and actually seems to break ScintillaEditPy */ + * is not required in C++ code and has caused problems in the past. */ typedef struct Sci_NotifyHeader Sci_NotifyHeader; typedef struct SCNotification SCNotification; #endif

Modified: scintilla/include/Scintilla.iface 102 lines changed, 101 insertions(+), 1 deletions(-) =================================================================== @@ -410,6 +410,8 @@ ali SC_MARKNUM_FOLDERTAIL=FOLDER_TAIL ali SC_MARKNUM_FOLDERSUB=FOLDER_SUB ali SC_MARKNUM_FOLDEROPEN=FOLDER_OPEN

+val SC_MASK_HISTORY=0x01E00000 + # SC_MASK_FOLDERS doesn't go in an enumeration as larger than max 32-bit positive integer val SC_MASK_FOLDERS=0xFE000000

@@ -698,6 +700,23 @@ set void StyleSetCheckMonospaced=2254(int style, bool checkMonospaced) # Get whether a style may be monospaced. get bool StyleGetCheckMonospaced=2255(int style,)

+enu FontStretch=SC_STRETCH_ +val SC_STRETCH_ULTRA_CONDENSED=1 +val SC_STRETCH_EXTRA_CONDENSED=2 +val SC_STRETCH_CONDENSED=3 +val SC_STRETCH_SEMI_CONDENSED=4 +val SC_STRETCH_NORMAL=5 +val SC_STRETCH_SEMI_EXPANDED=6 +val SC_STRETCH_EXPANDED=7 +val SC_STRETCH_EXTRA_EXPANDED=8 +val SC_STRETCH_ULTRA_EXPANDED=9 + +# Set the stretch of characters of a style. +set void StyleSetStretch=2258(int style, FontStretch stretch) + +# Get the stretch of characters of a style. +get FontStretch StyleGetStretch=2259(int style,) + # Set the invisible representation for a style. set void StyleSetInvisibleRepresentation=2256(int style, string representation)

@@ -717,6 +736,8 @@ val SC_ELEMENT_SELECTION_SECONDARY_TEXT=14 val SC_ELEMENT_SELECTION_SECONDARY_BACK=15 val SC_ELEMENT_SELECTION_INACTIVE_TEXT=16 val SC_ELEMENT_SELECTION_INACTIVE_BACK=17 +val SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_TEXT=18 +val SC_ELEMENT_SELECTION_INACTIVE_ADDITIONAL_BACK=19 val SC_ELEMENT_CARET=40 val SC_ELEMENT_CARET_ADDITIONAL=41 val SC_ELEMENT_CARET_LINE_BACK=50 @@ -833,6 +854,51 @@ fun void BeginUndoAction=2078(,) # End a sequence of actions that is undone and redone as a unit. fun void EndUndoAction=2079(,)

+# Is an undo sequence active? +get int GetUndoSequence=2799(,) + +# How many undo actions are in the history? +get int GetUndoActions=2790(,) + +# Set action as the save point +set void SetUndoSavePoint=2791(int action,) + +# Which action is the save point? +get int GetUndoSavePoint=2792(,) + +# Set action as the detach point +set void SetUndoDetach=2793(int action,) + +# Which action is the detach point? +get int GetUndoDetach=2794(,) + +# Set action as the tentative point +set void SetUndoTentative=2795(int action,) + +# Which action is the tentative point? +get int GetUndoTentative=2796(,) + +# Set action as the current point +set void SetUndoCurrent=2797(int action,) + +# Which action is the current point? +get int GetUndoCurrent=2798(,) + +# Push one action onto undo history with no text +fun void PushUndoActionType=2800(int type, position pos) + +# Set the text and length of the most recently pushed action +fun void ChangeLastUndoActionText=2801(position length, string text) + +# What is the type of an action? +get int GetUndoActionType=2802(int action,) + +# What is the position of an action? +get position GetUndoActionPosition=2803(int action,) + +# What is the text of an action? +get int GetUndoActionText=2804(int action, stringresult text) + # Indicator style enumeration and some constants enu IndicatorStyle=INDIC_ val INDIC_PLAIN=0 @@ -1058,6 +1124,8 @@ enu AutoCompleteOption=SC_AUTOCOMPLETE_ val SC_AUTOCOMPLETE_NORMAL=0 # Win32 specific: val SC_AUTOCOMPLETE_FIXED_SIZE=1 +# Always select the first item in the autocompletion list: +val SC_AUTOCOMPLETE_SELECT_FIRST_ITEM=2

# Set autocompletion options. set void AutoCSetOptions=2638(AutoCompleteOption options,) @@ -1100,6 +1168,12 @@ set void AutoCSetMaxHeight=2210(int rowCount,) # Set the maximum height, in rows, of auto-completion and user lists. get int AutoCGetMaxHeight=2211(,)

+# Set the style number used for auto-completion and user lists fonts. +set void AutoCSetStyle=2109(int style,) + +# Get the style number used for auto-completion and user lists fonts. +get int AutoCGetStyle=2120(,) + # Set the number of spaces used for one level of indentation. set void SetIndent=2122(int indentSize,)

@@ -1936,9 +2010,16 @@ fun void DeleteBack=2326(,) # If more than one line selected, indent the lines. fun void Tab=2327(,)

-# Dedent the selected lines. +# Indent the current and selected lines. +fun void LineIndent=2813(,) + +# If selection is empty or all on one line dedent the line if caret is at start, else move caret. +# If more than one line selected, dedent the lines. fun void BackTab=2328(,)

+# Dedent the current and selected lines. +fun void LineDedent=2814(,) + # Insert a new line, may use a CRLF, CR or LF depending on EOL mode. fun void NewLine=2329(,)

@@ -2359,9 +2440,16 @@ val SC_SEL_THIN=3 # by lines (SC_SEL_LINES). set void SetSelectionMode=2422(SelectionMode selectionMode,)

+# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or +# by lines (SC_SEL_LINES) without changing MoveExtendsSelection. +fun void ChangeSelectionMode=2659(SelectionMode selectionMode,) + # Get the mode of the current selection. get SelectionMode GetSelectionMode=2423(,)

+# Set whether or not regular caret moves will extend or reduce the selection. +set void SetMoveExtendsSelection=2719(bool moveExtendsSelection,) + # Get whether or not regular caret moves will extend or reduce the selection. get bool GetMoveExtendsSelection=2706(,)

@@ -2604,6 +2692,15 @@ get int GetLayoutThreads=2776(,) # Copy the selection, if selection empty copy the line with the caret fun void CopyAllowLine=2519(,)

+# Cut the selection, if selection empty cut the line with the caret +fun void CutAllowLine=2810(,) + +# Set the string to separate parts when copying a multiple selection. +set void SetCopySeparator=2811(, string separator) + +# Get the string to separate parts when copying a multiple selection. +get int GetCopySeparator=2812(, stringresult separator) + # Compact the document buffer and return a read-only pointer to the # characters in the document. get pointer GetCharacterPointer=2520(,) @@ -2790,6 +2887,9 @@ fun void SetSelection=2572(position caret, position anchor) # Add a selection fun void AddSelection=2573(position caret, position anchor)

+# Find the selection index for a point. -1 when not at a selection. +fun int SelectionFromPoint=2474(int x, int y) + # Drop one selection fun void DropSelectionN=2671(int selection,)

Modified: scintilla/include/ScintillaCall.h 41 lines changed, 36 insertions(+), 5 deletions(-) =================================================================== @@ -20,6 +20,8 @@ struct TextRangeFull; struct TextToFindFull; struct RangeToFormatFull;

+class IDocumentEditable; + using FunctionDirect = intptr_t(*)(intptr_t ptr, unsigned int iMessage, uintptr_t wParam, intptr_t lParam, int *pStatus);

struct Failure { @@ -207,6 +209,8 @@ class ScintillaCall { void StyleSetHotSpot(int style, bool hotspot); void StyleSetCheckMonospaced(int style, bool checkMonospaced); bool StyleGetCheckMonospaced(int style); + void StyleSetStretch(int style, Scintilla::FontStretch stretch); + Scintilla::FontStretch StyleGetStretch(int style); void StyleSetInvisibleRepresentation(int style, const char *representation); int StyleGetInvisibleRepresentation(int style, char *representation); std::string StyleGetInvisibleRepresentation(int style); @@ -243,6 +247,22 @@ class ScintillaCall { int CharacterCategoryOptimization(); void BeginUndoAction(); void EndUndoAction(); + int UndoSequence(); + int UndoActions(); + void SetUndoSavePoint(int action); + int UndoSavePoint(); + void SetUndoDetach(int action); + int UndoDetach(); + void SetUndoTentative(int action); + int UndoTentative(); + void SetUndoCurrent(int action); + int UndoCurrent(); + void PushUndoActionType(int type, Position pos); + void ChangeLastUndoActionText(Position length, const char *text); + int UndoActionType(int action); + Position UndoActionPosition(int action); + int UndoActionText(int action, char *text); + std::string UndoActionText(int action); void IndicSetStyle(int indicator, Scintilla::IndicatorStyle indicatorStyle); Scintilla::IndicatorStyle IndicGetStyle(int indicator); void IndicSetFore(int indicator, Colour fore); @@ -302,6 +322,8 @@ class ScintillaCall { int AutoCGetMaxWidth(); void AutoCSetMaxHeight(int rowCount); int AutoCGetMaxHeight(); + void AutoCSetStyle(int style); + int AutoCGetStyle(); void SetIndent(int indentSize); int Indent(); void SetUseTabs(bool useTabs); @@ -520,7 +542,9 @@ class ScintillaCall { void Cancel(); void DeleteBack(); void Tab(); + void LineIndent(); void BackTab(); + void LineDedent(); void NewLine(); void FormFeed(); void VCHome(); @@ -561,8 +585,8 @@ class ScintillaCall { Position BraceMatchNext(Position pos, Position startPos); bool ViewEOL(); void SetViewEOL(bool visible); - void *DocPointer(); - void SetDocPointer(void *doc); + IDocumentEditable *DocPointer(); + void SetDocPointer(IDocumentEditable *doc); void SetModEventMask(Scintilla::ModificationFlags eventMask); Position EdgeColumn(); void SetEdgeColumn(Position column); @@ -581,9 +605,9 @@ class ScintillaCall { bool SelectionIsRectangle(); void SetZoom(int zoomInPoints); int Zoom(); - void *CreateDocument(Position bytes, Scintilla::DocumentOption documentOptions); - void AddRefDocument(void *doc); - void ReleaseDocument(void *doc); + IDocumentEditable *CreateDocument(Position bytes, Scintilla::DocumentOption documentOptions); + void AddRefDocument(IDocumentEditable *doc); + void ReleaseDocument(IDocumentEditable *doc); Scintilla::DocumentOption DocumentOptions(); Scintilla::ModificationFlags ModEventMask(); void SetCommandEvents(bool commandEvents); @@ -634,7 +658,9 @@ class ScintillaCall { void CopyRange(Position start, Position end); void CopyText(Position length, const char *text); void SetSelectionMode(Scintilla::SelectionMode selectionMode); + void ChangeSelectionMode(Scintilla::SelectionMode selectionMode); Scintilla::SelectionMode SelectionMode(); + void SetMoveExtendsSelection(bool moveExtendsSelection); bool MoveExtendsSelection(); Position GetLineSelStartPosition(Line line); Position GetLineSelEndPosition(Line line); @@ -704,6 +730,10 @@ class ScintillaCall { void SetLayoutThreads(int threads); int LayoutThreads(); void CopyAllowLine(); + void CutAllowLine(); + void SetCopySeparator(const char *separator); + int CopySeparator(char *separator); + std::string CopySeparator(); void *CharacterPointer(); void *RangePointer(Position start, Position lengthRange); Position GapPosition(); @@ -763,6 +793,7 @@ class ScintillaCall { void ClearSelections(); void SetSelection(Position caret, Position anchor); void AddSelection(Position caret, Position anchor); + int SelectionFromPoint(int x, int y); void DropSelectionN(int selection); void SetMainSelection(int selection); int MainSelection();

Modified: scintilla/include/ScintillaMessages.h 27 lines changed, 27 insertions(+), 0 deletions(-) =================================================================== @@ -137,6 +137,8 @@ enum class Message { StyleSetHotSpot = 2409, StyleSetCheckMonospaced = 2254, StyleGetCheckMonospaced = 2255, + StyleSetStretch = 2258, + StyleGetStretch = 2259, StyleSetInvisibleRepresentation = 2256, StyleGetInvisibleRepresentation = 2257, SetElementColour = 2753, @@ -171,6 +173,21 @@ enum class Message { GetCharacterCategoryOptimization = 2721, BeginUndoAction = 2078, EndUndoAction = 2079, + GetUndoSequence = 2799, + GetUndoActions = 2790, + SetUndoSavePoint = 2791, + GetUndoSavePoint = 2792, + SetUndoDetach = 2793, + GetUndoDetach = 2794, + SetUndoTentative = 2795, + GetUndoTentative = 2796, + SetUndoCurrent = 2797, + GetUndoCurrent = 2798, + PushUndoActionType = 2800, + ChangeLastUndoActionText = 2801, + GetUndoActionType = 2802, + GetUndoActionPosition = 2803, + GetUndoActionText = 2804, IndicSetStyle = 2080, IndicGetStyle = 2081, IndicSetFore = 2082, @@ -230,6 +247,8 @@ enum class Message { AutoCGetMaxWidth = 2209, AutoCSetMaxHeight = 2210, AutoCGetMaxHeight = 2211, + AutoCSetStyle = 2109, + AutoCGetStyle = 2120, SetIndent = 2122, GetIndent = 2123, SetUseTabs = 2124, @@ -442,7 +461,9 @@ enum class Message { Cancel = 2325, DeleteBack = 2326, Tab = 2327, + LineIndent = 2813, BackTab = 2328, + LineDedent = 2814, NewLine = 2329, FormFeed = 2330, VCHome = 2331, @@ -556,7 +577,9 @@ enum class Message { CopyRange = 2419, CopyText = 2420, SetSelectionMode = 2422, + ChangeSelectionMode = 2659, GetSelectionMode = 2423, + SetMoveExtendsSelection = 2719, GetMoveExtendsSelection = 2706, GetLineSelStartPosition = 2424, GetLineSelEndPosition = 2425, @@ -621,6 +644,9 @@ enum class Message { SetLayoutThreads = 2775, GetLayoutThreads = 2776, CopyAllowLine = 2519, + CutAllowLine = 2810, + SetCopySeparator = 2811, + GetCopySeparator = 2812, GetCharacterPointer = 2520, GetRangePointer = 2643, GetGapPosition = 2644, @@ -676,6 +702,7 @@ enum class Message { ClearSelections = 2571, SetSelection = 2572, AddSelection = 2573, + SelectionFromPoint = 2474, DropSelectionN = 2671, SetMainSelection = 2574, GetMainSelection = 2575,

Modified: scintilla/include/ScintillaTypes.h 16 lines changed, 16 insertions(+), 0 deletions(-) =================================================================== @@ -165,6 +165,18 @@ enum class FontWeight { Bold = 700, };

+enum class FontStretch { + UltraCondensed = 1, + ExtraCondensed = 2, + Condensed = 3, + SemiCondensed = 4, + Normal = 5, + SemiExpanded = 6, + Expanded = 7, + ExtraExpanded = 8, + UltraExpanded = 9, +}; + enum class Element { List = 0, ListBack = 1, @@ -178,6 +190,8 @@ enum class Element { SelectionSecondaryBack = 15, SelectionInactiveText = 16, SelectionInactiveBack = 17, + SelectionInactiveAdditionalText = 18, + SelectionInactiveAdditionalBack = 19, Caret = 40, CaretAdditional = 41, CaretLineBack = 50, @@ -249,6 +263,7 @@ enum class IndicFlag { enum class AutoCompleteOption { Normal = 0, FixedSize = 1, + SelectFirstItem = 2, };

enum class IndentView { @@ -687,6 +702,7 @@ using sptr_t = intptr_t; constexpr Position InvalidPosition = -1; constexpr int CpUtf8 = 65001; constexpr int MarkerMax = 31; +constexpr int MaskHistory = 0x01E00000; constexpr int MaskFolders = 0xFE000000; constexpr int MaxMargin = 4; constexpr int FontSizeMultiplier = 100;

Modified: scintilla/lexilla/include/Lexilla.h 16 lines changed, 8 insertions(+), 8 deletions(-) =================================================================== @@ -48,20 +48,20 @@ using Scintilla::ILexer5; typedef void ILexer5; #endif

-typedef ILexer5 *(*LexerFactoryFunction)(); +typedef ILexer5 *(*LexerFactoryFunction)(void);

#if defined(__cplusplus) namespace Lexilla { #endif

-typedef int (LEXILLA_CALL *GetLexerCountFn)(); +typedef int (LEXILLA_CALL *GetLexerCountFn)(void); typedef void (LEXILLA_CALL *GetLexerNameFn)(unsigned int Index, char *name, int buflength); typedef LexerFactoryFunction(LEXILLA_CALL *GetLexerFactoryFn)(unsigned int Index); typedef ILexer5*(LEXILLA_CALL *CreateLexerFn)(const char *name); DEPRECATE_DEFINITION typedef const char *(LEXILLA_CALL *LexerNameFromIDFn)(int identifier); -typedef const char *(LEXILLA_CALL *GetLibraryPropertyNamesFn)(); +typedef const char *(LEXILLA_CALL *GetLibraryPropertyNamesFn)(void); typedef void(LEXILLA_CALL *SetLibraryPropertyFn)(const char *key, const char *value); -typedef const char *(LEXILLA_CALL *GetNameSpaceFn)(); +typedef const char *(LEXILLA_CALL *GetNameSpaceFn)(void);

#if defined(__cplusplus) } @@ -85,13 +85,13 @@ extern "C" { #endif

ILexer5 * LEXILLA_CALL CreateLexer(const char *name); -int LEXILLA_CALL GetLexerCount(); +int LEXILLA_CALL GetLexerCount(void); void LEXILLA_CALL GetLexerName(unsigned int index, char *name, int buflength); LexerFactoryFunction LEXILLA_CALL GetLexerFactory(unsigned int index); DEPRECATE_DEFINITION const char *LEXILLA_CALL LexerNameFromID(int identifier); -const char * LEXILLA_CALL GetLibraryPropertyNames(); +const char * LEXILLA_CALL GetLibraryPropertyNames(void); void LEXILLA_CALL SetLibraryProperty(const char *key, const char *value); -const char *LEXILLA_CALL GetNameSpace(); +const char *LEXILLA_CALL GetNameSpace(void);

#if defined(__cplusplus) } @@ -102,7 +102,7 @@ namespace Lexilla { class LexerModule; } // Add a static lexer (in the same binary) to Lexilla's list -void AddStaticLexerModule(Lexilla::LexerModule *plm); +void AddStaticLexerModule(const Lexilla::LexerModule *plm); #endif

#endif

Modified: scintilla/lexilla/include/SciLexer.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -1810,6 +1810,8 @@ #define SCE_RUST_BYTESTRING 21 #define SCE_RUST_BYTESTRINGR 22 #define SCE_RUST_BYTECHARACTER 23 +#define SCE_RUST_CSTRING 24 +#define SCE_RUST_CSTRINGR 25 #define SCE_DMAP_DEFAULT 0 #define SCE_DMAP_COMMENT 1 #define SCE_DMAP_NUMBER 2

Modified: scintilla/lexilla/lexers/LexAU3.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -908,4 +908,4 @@ static const char * const AU3WordLists[] = { "#autoit UDF", 0 }; -LexerModule lmAU3(SCLEX_AU3, ColouriseAU3Doc, "au3", FoldAU3Doc , AU3WordLists); +extern const LexerModule lmAU3(SCLEX_AU3, ColouriseAU3Doc, "au3", FoldAU3Doc , AU3WordLists);

Modified: scintilla/lexilla/lexers/LexAbaqus.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -603,4 +603,4 @@ static const char * const abaqusWordListDesc[] = { 0 };

-LexerModule lmAbaqus(SCLEX_ABAQUS, ColouriseABAQUSDoc, "abaqus", FoldABAQUSDoc, abaqusWordListDesc); +extern const LexerModule lmAbaqus(SCLEX_ABAQUS, ColouriseABAQUSDoc, "abaqus", FoldABAQUSDoc, abaqusWordListDesc);

Modified: scintilla/lexilla/lexers/LexAda.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -44,7 +44,7 @@ static const char * const adaWordListDesc[] = { 0 };

-LexerModule lmAda(SCLEX_ADA, ColouriseDocument, "ada", NULL, adaWordListDesc); +extern const LexerModule lmAda(SCLEX_ADA, ColouriseDocument, "ada", NULL, adaWordListDesc);

/* * Implementation

Modified: scintilla/lexilla/lexers/LexAsciidoc.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -390,4 +390,4 @@ static void ColorizeAsciidocDoc(Sci_PositionU startPos, Sci_Position length, int sc.Complete(); }

-LexerModule lmAsciidoc(SCLEX_ASCIIDOC, ColorizeAsciidocDoc, "asciidoc"); +extern const LexerModule lmAsciidoc(SCLEX_ASCIIDOC, ColorizeAsciidocDoc, "asciidoc");

Modified: scintilla/lexilla/lexers/LexAsm.cxx 89 lines changed, 44 insertions(+), 45 deletions(-) =================================================================== @@ -9,12 +9,12 @@ // Copyright 1998-2003 by Neil Hodgson neilh@scintilla.org // The License.txt file describes the conditions under which this software may be distributed.

-#include <stdlib.h> -#include <string.h> -#include <stdio.h> -#include <stdarg.h> -#include <assert.h> -#include <ctype.h> +#include <cstdlib> +#include <cassert> +#include <cstring> +#include <cctype> +#include <cstdio> +#include <cstdarg>

#include <string> #include <string_view> @@ -37,17 +37,19 @@ using namespace Scintilla; using namespace Lexilla;

-static inline bool IsAWordChar(const int ch) { +namespace { + +bool IsAWordChar(const int ch) noexcept { return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '?'); }

-static inline bool IsAWordStart(const int ch) { +bool IsAWordStart(const int ch) noexcept { return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' || ch == '%' || ch == '@' || ch == '$' || ch == '?'); }

-static inline bool IsAsmOperator(const int ch) { +bool IsAsmOperator(const int ch) noexcept { if ((ch < 0x80) && (isalnum(ch))) return false; // '.' left out as it is used to make up numbers @@ -60,16 +62,10 @@ static inline bool IsAsmOperator(const int ch) { return false; }

-static bool IsStreamCommentStyle(int style) { +constexpr bool IsStreamCommentStyle(int style) noexcept { return style == SCE_ASM_COMMENTDIRECTIVE || style == SCE_ASM_COMMENTBLOCK; }

-static inline int LowerCase(int c) { - if (c >= 'A' && c <= 'Z') - return 'a' + c - 'A'; - return c; -} - // An individual named option for use in an OptionSet

// Options used for LexerAsm @@ -98,7 +94,7 @@ struct OptionsAsm { } };

-static const char * const asmWordListDesc[] = { +const char *const asmWordListDesc[] = { "CPU instructions", "FPU instructions", "Registers", @@ -107,7 +103,7 @@ static const char * const asmWordListDesc[] = { "Extended instructions", "Directives4Foldstart", "Directives4Foldend", - 0 + nullptr };

struct OptionSetAsm : public OptionSet<OptionsAsm> { @@ -191,7 +187,7 @@ class LexerAsm : public DefaultLexer { void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;

void * SCI_METHOD PrivateCall(int, void *) override { - return 0; + return nullptr; }

static ILexer5 *LexerFactoryAsm() { @@ -211,7 +207,7 @@ Sci_Position SCI_METHOD LexerAsm::PropertySet(const char *key, const char *val) }

Sci_Position SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) { - WordList *wordListN = 0; + WordList *wordListN = nullptr; switch (n) { case 0: wordListN = &cpuInstruction; @@ -240,10 +236,7 @@ Sci_Position SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) { } Sci_Position firstModification = -1; if (wordListN) { - WordList wlNew; - wlNew.Set(wl); - if (*wordListN != wlNew) { - wordListN->Set(wl); + if (wordListN->Set(wl, true)) { firstModification = 0; } } @@ -265,11 +258,19 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i for (; sc.More(); sc.Forward()) {

- // Prevent SCE_ASM_STRINGEOL from leaking back to previous line - if (sc.atLineStart && (sc.state == SCE_ASM_STRING)) { - sc.SetState(SCE_ASM_STRING); - } else if (sc.atLineStart && (sc.state == SCE_ASM_CHARACTER)) { - sc.SetState(SCE_ASM_CHARACTER); + if (sc.atLineStart) { + switch (sc.state) { + case SCE_ASM_STRING: + case SCE_ASM_CHARACTER: + // Prevent SCE_ASM_STRINGEOL from leaking back to previous line + sc.SetState(sc.state); + break; + case SCE_ASM_COMMENT: + sc.SetState(SCE_ASM_DEFAULT); + break; + default: + break; + } }

// Handle line continuation generically. @@ -314,7 +315,7 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i } sc.SetState(SCE_ASM_DEFAULT); if (IsDirective && !strcmp(s, "comment")) { - char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0]; + const char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0]; while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd) { sc.ForwardSetState(SCE_ASM_DEFAULT); } @@ -324,17 +325,13 @@ void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int i } } } else if (sc.state == SCE_ASM_COMMENTDIRECTIVE) { - char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0]; + const char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0]; if (sc.ch == delimiter) { - while (!sc.atLineEnd) { + while (!sc.MatchLineEnd()) { sc.Forward(); } sc.SetState(SCE_ASM_DEFAULT); } - } else if (sc.state == SCE_ASM_COMMENT ) { - if (sc.atLineEnd) { - sc.SetState(SCE_ASM_DEFAULT); - } } else if (sc.state == SCE_ASM_STRING) { if (sc.ch == '\') { if (sc.chNext == '"' || sc.chNext == ''' || sc.chNext == '\') { @@ -391,7 +388,7 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int

LexAccessor styler(pAccess);

- Sci_PositionU endPos = startPos + length; + const Sci_PositionU endPos = startPos + length; int visibleChars = 0; Sci_Position lineCurrent = styler.GetLine(startPos); int levelCurrent = SC_FOLDLEVELBASE; @@ -401,16 +398,16 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int char chNext = styler[startPos]; int styleNext = styler.StyleAt(startPos); int style = initStyle; - char word[100]; + char word[100]{}; int wordlen = 0; const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty(); for (Sci_PositionU i = startPos; i < endPos; i++) { - char ch = chNext; + const char ch = chNext; chNext = styler.SafeGetCharAt(i + 1); - int stylePrev = style; + const int stylePrev = style; style = styleNext; styleNext = styler.StyleAt(i + 1); - bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); + const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); if (options.foldCommentMultiline && IsStreamCommentStyle(style)) { if (!IsStreamCommentStyle(stylePrev)) { levelNext++; @@ -437,7 +434,7 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int } } if (options.foldSyntaxBased && (style == SCE_ASM_DIRECTIVE)) { - word[wordlen++] = static_cast<char>(LowerCase(ch)); + word[wordlen++] = MakeLowerCase(ch); if (wordlen == 100) { // prevent overflow word[0] = '\0'; wordlen = 1; @@ -455,7 +452,7 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int if (!IsASpace(ch)) visibleChars++; if (atEOL || (i == endPos-1)) { - int levelUse = levelCurrent; + const int levelUse = levelCurrent; int lev = levelUse | levelNext << 16; if (visibleChars == 0 && options.foldCompact) lev |= SC_FOLDLEVELWHITEFLAG; @@ -475,6 +472,8 @@ void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int } }

-LexerModule lmAsm(SCLEX_ASM, LexerAsm::LexerFactoryAsm, "asm", asmWordListDesc); -LexerModule lmAs(SCLEX_AS, LexerAsm::LexerFactoryAs, "as", asmWordListDesc); +} + +extern const LexerModule lmAsm(SCLEX_ASM, LexerAsm::LexerFactoryAsm, "asm", asmWordListDesc); +extern const LexerModule lmAs(SCLEX_AS, LexerAsm::LexerFactoryAs, "as", asmWordListDesc);

Modified: scintilla/lexilla/lexers/LexBash.cxx 86 lines changed, 51 insertions(+), 35 deletions(-) =================================================================== @@ -16,13 +16,15 @@ #include <string_view> #include <vector> #include <map> +#include <initializer_list> #include <functional>

#include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h"

#include "StringCopy.h" +#include "InList.h" #include "WordList.h" #include "LexAccessor.h" #include "StyleContext.h" @@ -63,7 +65,7 @@ enum class CmdState { Delimiter, };

-enum class CommandSubstitution { +enum class CommandSubstitution : int { Backtick, Inside, InsideTrack, @@ -181,7 +183,7 @@ struct OptionsBash { bool stylingInsideParameter = false; bool stylingInsideHeredoc = false; bool nestedBackticks = true; - int commandSubstitution = static_cast<int>(CommandSubstitution::Backtick); + CommandSubstitution commandSubstitution = CommandSubstitution::Backtick; std::string specialParameter = BASH_SPECIAL_PARAMETER;

[[nodiscard]] bool stylingInside(int state) const noexcept { @@ -333,7 +335,7 @@ class QuoteStackCls { // Class to manage quote pairs that nest } bool CountDown(StyleContext &sc, CmdState &cmdState) { Current.Count--; - if (Current.Count == 1 && sc.Match(')', ')')) { + while (Current.Count > 0 && sc.chNext == Current.Down) { Current.Count--; sc.Forward(); } @@ -380,10 +382,6 @@ class QuoteStackCls { // Class to manage quote pairs that nest sc.ChangeState(SCE_SH_BACKTICKS); } } - if (current == CmdState::Body && sc.Match('(', '(') && state == SCE_SH_DEFAULT && Depth == 0) { - // optimized to avoid track nested delimiter pairs - style = QuoteStyle::Literal; - } } else { // scalar has no delimiter pair if (!setParamStart.Contains(sc.ch)) { @@ -470,7 +468,7 @@ const LexicalClass lexicalClasses[] = { 10, "SCE_SH_PARAM", "identifier", "Parameter", 11, "SCE_SH_BACKTICKS", "literal string", "Backtick quoted command", 12, "SCE_SH_HERE_DELIM", "operator", "Heredoc delimiter", - 13, "SCE_SH_HERE_Q", "literal string", "Heredoc quoted string", + 13, "SCE_SH_HERE_Q", "here-doc literal string", "Heredoc quoted string", };

} @@ -485,12 +483,11 @@ class LexerBash final : public DefaultLexer { OptionSetBash osBash; CharacterSet setParamStart; enum { ssIdentifier, ssScalar }; - SubStyles subStyles; + SubStyles subStyles{styleSubable}; public: LexerBash() : - DefaultLexer("bash", SCLEX_BASH, lexicalClasses, ELEMENTS(lexicalClasses)), - setParamStart(CharacterSet::setAlphaNum, "_" BASH_SPECIAL_PARAMETER), - subStyles(styleSubable, 0x80, 0x40, 0) { + DefaultLexer("bash", SCLEX_BASH, lexicalClasses, std::size(lexicalClasses)), + setParamStart(CharacterSet::setAlphaNum, "_" BASH_SPECIAL_PARAMETER) { cmdDelimiter.Set("| || |& & && ; ;; ( ) { }"); bashStruct.Set("if elif fi while until else then do done esac eval"); bashStruct_in.Set("for case select"); @@ -614,6 +611,7 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int bool Quoted = false; // true if Quote in (''','"','`') bool Escaped = false; // backslash in delimiter, common in configure script bool Indent = false; // indented delimiter (for <<-) + int BackslashCount = 0; int DelimiterLength = 0; // strlen(Delimiter) char Delimiter[HERE_DELIM_MAX]{}; // the Delimiter HereDocCls() noexcept = default; @@ -626,7 +624,7 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int

QuoteStackCls QuoteStack(setParamStart); QuoteStack.nestedBackticks = options.nestedBackticks; - QuoteStack.commandSubstitution = static_cast<CommandSubstitution>(options.commandSubstitution); + QuoteStack.commandSubstitution = options.commandSubstitution;

const WordClassifier &classifierIdentifiers = subStyles.Classifier(SCE_SH_IDENTIFIER); const WordClassifier &classifierScalars = subStyles.Classifier(SCE_SH_SCALAR); @@ -834,6 +832,7 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int HereDoc.Quote = sc.chNext; HereDoc.Quoted = false; HereDoc.Escaped = false; + HereDoc.BackslashCount = 0; HereDoc.DelimiterLength = 0; HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0'; if (sc.chNext == ''' || sc.chNext == '"') { // a quoted here-doc delimiter (' or ") @@ -861,22 +860,21 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int } else if (HereDoc.State == 1) { // collect the delimiter // * if single quoted, there's no escape // * if double quoted, there are \ and " escapes - if ((HereDoc.Quote == ''' && sc.ch != HereDoc.Quote) || - (HereDoc.Quoted && sc.ch != HereDoc.Quote && sc.ch != '\') || - (HereDoc.Quote != ''' && sc.chPrev == '\') || - (setHereDoc2.Contains(sc.ch))) { - HereDoc.Append(sc.ch); - } else if (HereDoc.Quoted && sc.ch == HereDoc.Quote) { // closing quote => end of delimiter - sc.ForwardSetState(SCE_SH_DEFAULT); - } else if (sc.ch == '\') { + if (HereDoc.Quoted && sc.ch == HereDoc.Quote && (HereDoc.BackslashCount & 1) == 0) { // closing quote => end of delimiter + sc.ForwardSetState(SCE_SH_DEFAULT | insideCommand); + } else if (sc.ch == '\' && HereDoc.Quote != ''') { HereDoc.Escaped = true; - if (HereDoc.Quoted && sc.chNext != HereDoc.Quote && sc.chNext != '\') { + HereDoc.BackslashCount += 1; + if ((HereDoc.BackslashCount & 1) == 0 || (HereDoc.Quoted && !AnyOf(sc.chNext, '"', '\'))) { // in quoted prefixes only \ and the quote eat the escape HereDoc.Append(sc.ch); } else { // skip escape prefix } - } else if (!HereDoc.Quoted) { + } else if (HereDoc.Quoted || setHereDoc2.Contains(sc.ch) || (sc.ch > 32 && sc.ch < 127 && (HereDoc.BackslashCount & 1) != 0)) { + HereDoc.BackslashCount = 0; + HereDoc.Append(sc.ch); + } else { sc.SetState(SCE_SH_DEFAULT | insideCommand); } if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) { // force blowup @@ -939,7 +937,9 @@ void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int continue; } } else if (sc.ch == QuoteStack.Current.Up) { - QuoteStack.Current.Count++; + if (QuoteStack.Current.Style != QuoteStyle::Parameter) { + QuoteStack.Current.Count++; + } } else { if (QuoteStack.Current.Style == QuoteStyle::String || QuoteStack.Current.Style == QuoteStyle::HereDoc || @@ -1189,10 +1189,17 @@ void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos_, Sci_Position length, in

LexAccessor styler(pAccess);

- const Sci_Position startPos = startPos_; + Sci_Position startPos = startPos_; const Sci_Position endPos = startPos + length; int visibleChars = 0; Sci_Position lineCurrent = styler.GetLine(startPos); + // Backtrack to previous line in case need to fix its fold status + if (lineCurrent > 0) { + lineCurrent--; + startPos = styler.LineStart(lineCurrent); + initStyle = (startPos > 0) ? styler.StyleIndexAt(startPos - 1) : 0; + } + int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK; int levelCurrent = levelPrev; char chNext = styler[startPos]; @@ -1217,28 +1224,32 @@ void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos_, Sci_Position length, in && !IsCommentLine(lineCurrent + 1, styler)) levelCurrent--; } - if (style == SCE_SH_WORD) { + + switch (style) { + case SCE_SH_WORD: if ((wordlen + 1) < sizeof(word)) word[wordlen++] = ch; if (styleNext != style) { word[wordlen] = '\0'; wordlen = 0; - if (strcmp(word, "if") == 0 || strcmp(word, "case") == 0 || strcmp(word, "do") == 0) { + if (InList(word, {"if", "case", "do"})) { levelCurrent++; - } else if (strcmp(word, "fi") == 0 || strcmp(word, "esac") == 0 || strcmp(word, "done") == 0) { + } else if (InList(word, {"fi", "esac", "done"})) { levelCurrent--; } } - } - if (style == SCE_SH_OPERATOR) { + break; + + case SCE_SH_OPERATOR: if (ch == '{') { levelCurrent++; } else if (ch == '}') { levelCurrent--; } - } + break; + // Here Document folding - if (style == SCE_SH_HERE_DELIM) { + case SCE_SH_HERE_DELIM: if (stylePrev == SCE_SH_HERE_Q) { levelCurrent--; } else if (stylePrev != SCE_SH_HERE_DELIM) { @@ -1248,9 +1259,14 @@ void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos_, Sci_Position length, in } } } - } else if (style == SCE_SH_HERE_Q && styleNext == SCE_SH_DEFAULT) { - levelCurrent--; + break; + case SCE_SH_HERE_Q: + if (styleNext == SCE_SH_DEFAULT) { + levelCurrent--; + } + break; } + if (atEOL) { int lev = levelPrev; if (visibleChars == 0 && options.foldCompact) @@ -1272,4 +1288,4 @@ void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos_, Sci_Position length, in styler.SetLevel(lineCurrent, levelPrev | flagsNext); }

-LexerModule lmBash(SCLEX_BASH, LexerBash::LexerFactoryBash, "bash", bashWordListDesc); +extern const LexerModule lmBash(SCLEX_BASH, LexerBash::LexerFactoryBash, "bash", bashWordListDesc);

Modified: scintilla/lexilla/lexers/LexBasic.cxx 6 lines changed, 3 insertions(+), 3 deletions(-) =================================================================== @@ -566,8 +566,8 @@ void SCI_METHOD LexerBasic::Fold(Sci_PositionU startPos, Sci_Position length, in } }

-LexerModule lmBlitzBasic(SCLEX_BLITZBASIC, LexerBasic::LexerFactoryBlitzBasic, "blitzbasic", blitzbasicWordListDesc); +extern const LexerModule lmBlitzBasic(SCLEX_BLITZBASIC, LexerBasic::LexerFactoryBlitzBasic, "blitzbasic", blitzbasicWordListDesc);

-LexerModule lmPureBasic(SCLEX_PUREBASIC, LexerBasic::LexerFactoryPureBasic, "purebasic", purebasicWordListDesc); +extern const LexerModule lmPureBasic(SCLEX_PUREBASIC, LexerBasic::LexerFactoryPureBasic, "purebasic", purebasicWordListDesc);

-LexerModule lmFreeBasic(SCLEX_FREEBASIC, LexerBasic::LexerFactoryFreeBasic, "freebasic", freebasicWordListDesc); +extern const LexerModule lmFreeBasic(SCLEX_FREEBASIC, LexerBasic::LexerFactoryFreeBasic, "freebasic", freebasicWordListDesc);

Modified: scintilla/lexilla/lexers/LexBatch.cxx 74 lines changed, 36 insertions(+), 38 deletions(-) =================================================================== @@ -14,11 +14,13 @@

#include <string> #include <string_view> +#include <initializer_list>

#include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h"

+#include "InList.h" #include "WordList.h" #include "LexAccessor.h" #include "Accessor.h" @@ -57,7 +59,7 @@ constexpr bool IsBSeparator(char ch) noexcept { }

// Tests for escape character -bool IsEscaped(const char* wordStr, Sci_PositionU pos) noexcept { +constexpr bool IsEscaped(const char* wordStr, Sci_PositionU pos) noexcept { bool isQoted=false; while (pos>0){ pos--; @@ -69,30 +71,24 @@ bool IsEscaped(const char* wordStr, Sci_PositionU pos) noexcept { return isQoted; }

-// Tests for quote character -bool textQuoted(const char *lineBuffer, Sci_PositionU endPos) { - char strBuffer[1024]; - strncpy(strBuffer, lineBuffer, endPos); - strBuffer[endPos] = '\0'; +constexpr bool IsQuotedBy(std::string_view svBuffer, char quote) noexcept { bool CurrentStatus = false; - const char strQuotes[] = ""'"; - const size_t strLength = strlen(strQuotes); - for (size_t i = 0; i < strLength; i++) { - const char *pQuote = strchr(strBuffer, strQuotes[i]); - while (pQuote) - { - if (!IsEscaped(strBuffer, pQuote - strBuffer)) { - CurrentStatus = !CurrentStatus; - } - pQuote = strchr(pQuote + 1, strQuotes[i]); - } - if (CurrentStatus) { - break; + size_t pQuote = svBuffer.find(quote); + while (pQuote != std::string_view::npos) { + if (!IsEscaped(svBuffer.data(), pQuote)) { + CurrentStatus = !CurrentStatus; } + pQuote = svBuffer.find(quote, pQuote + 1); } return CurrentStatus; }

+// Tests for quote character +constexpr bool textQuoted(const char *lineBuffer, Sci_PositionU endPos) noexcept { + const std::string_view svBuffer(lineBuffer, endPos); + return IsQuotedBy(svBuffer, '"') || IsQuotedBy(svBuffer, '''); +} + void ColouriseBatchDoc( Sci_PositionU startPos, Sci_Position length, @@ -200,18 +196,19 @@ void ColouriseBatchDoc( styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT); } char wordBuffer[81]{}; // Word Buffer - large to catch long paths - // Copy word from Line Buffer into Word Buffer + // Copy word from Line Buffer into Word Buffer and convert to lower case Sci_PositionU wbl = 0; // Word Buffer Length for (; offset < lengthLine && wbl < 80 && !isspacechar(lineBuffer[offset]); wbl++, offset++) { - wordBuffer[wbl] = tolower(lineBuffer[offset]); + wordBuffer[wbl] = MakeLowerCase(lineBuffer[offset]); } wordBuffer[wbl] = '\0'; + const std::string_view wordView(wordBuffer); Sci_PositionU wbo = 0; // Word Buffer Offset - also Special Keyword Buffer Length

// Check for Comment - return if found if (continueProcessing) { - if ((CompareCaseInsensitive(wordBuffer, "rem") == 0) || (wordBuffer[0] == ':' && wordBuffer[1] == ':')) { + if ((wordView == "rem") || (wordBuffer[0] == ':' && wordBuffer[1] == ':')) { if ((offset == wbl) || !textQuoted(lineBuffer, offset - wbl)) { styler.ColourTo(startLine + offset - wbl - 1, SCE_BAT_DEFAULT); styler.ColourTo(endPos, SCE_BAT_COMMENT); @@ -248,19 +245,16 @@ void ColouriseBatchDoc( } else if ((keywords.InList(wordBuffer)) && (continueProcessing)) { // ECHO, GOTO, PROMPT and SET require no further Regular Keyword Checking - if ((CompareCaseInsensitive(wordBuffer, "echo") == 0) || - (CompareCaseInsensitive(wordBuffer, "goto") == 0) || - (CompareCaseInsensitive(wordBuffer, "prompt") == 0)) { + if (InList(wordView, {"echo", "goto", "prompt"})) { continueProcessing = false; } // SET requires additional processing for the assignment operator - if (CompareCaseInsensitive(wordBuffer, "set") == 0) { + if (wordView == "set") { continueProcessing = false; isNotAssigned=true; } // Identify External Command / Program Location for ERRORLEVEL, and EXIST - if ((CompareCaseInsensitive(wordBuffer, "errorlevel") == 0) || - (CompareCaseInsensitive(wordBuffer, "exist") == 0)) { + if (InList(wordView, {"errorlevel", "exist"})) { // Reset External Command / Program Location cmdLoc = offset; // Skip next spaces @@ -279,17 +273,19 @@ void ColouriseBatchDoc( cmdLoc++; } // Identify External Command / Program Location for CALL, DO, LOADHIGH and LH - } else if ((CompareCaseInsensitive(wordBuffer, "call") == 0) || - (CompareCaseInsensitive(wordBuffer, "do") == 0) || - (CompareCaseInsensitive(wordBuffer, "loadhigh") == 0) || - (CompareCaseInsensitive(wordBuffer, "lh") == 0)) { + } else if (InList(wordView, {"call", "do", "loadhigh", "lh"})) { // Reset External Command / Program Location cmdLoc = offset; // Skip next spaces while ((cmdLoc < lengthLine) && (isspacechar(lineBuffer[cmdLoc]))) { cmdLoc++; } + // Check if call is followed by a label + if ((lineBuffer[cmdLoc] == ':') && + (wordView == "call")) { + continueProcessing = false; + } } // Colorize Regular keyword styler.ColourTo(startLine + offset - 1, SCE_BAT_WORD); @@ -317,10 +313,12 @@ void ColouriseBatchDoc( // Check for Special Keyword in list if ((keywords.InList(sKeywordBuffer)) && ((IsBOperator(wordBuffer[wbo])) || - (IsBSeparator(wordBuffer[wbo])))) { + (IsBSeparator(wordBuffer[wbo])) || + (wordBuffer[wbo] == ':' && + (InList(sKeywordBuffer, {"call", "echo", "goto"}) )))) { sKeywordFound = true; // ECHO requires no further Regular Keyword Checking - if (CompareCaseInsensitive(sKeywordBuffer, "echo") == 0) { + if (std::string_view(sKeywordBuffer) == "echo") { continueProcessing = false; } // Colorize Special Keyword as Regular Keyword @@ -347,11 +345,11 @@ void ColouriseBatchDoc( // Reset Offset to re-process remainder of word offset -= (wbl - wbo); // CHOICE requires no further Regular Keyword Checking - if (CompareCaseInsensitive(wordBuffer, "choice") == 0) { + if (wordView == "choice") { continueProcessing = false; } // Check for START (and its switches) - What follows is External Command \ Program - if (CompareCaseInsensitive(wordBuffer, "start") == 0) { + if (wordView == "start") { // Reset External Command / Program Location cmdLoc = offset; // Skip next spaces @@ -576,7 +574,7 @@ void ColouriseBatchDoc( isNotAssigned=false; } // Colorize Other Operators - // Do not Colorize Paranthesis, quoted text and escaped operators + // Do not Colorize Parenthesis, quoted text and escaped operators if (((wordBuffer[0] != ')') && (wordBuffer[0] != '(') && !textQuoted(lineBuffer, offset - wbl) && !IsEscaped(lineBuffer,offset - wbl + wbo)) && !((wordBuffer[0] == '=') && !isNotAssigned )) @@ -645,4 +643,4 @@ const char *const batchWordListDesc[] = {

}

-LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc, "batch", nullptr, batchWordListDesc); +extern const LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc, "batch", nullptr, batchWordListDesc);

Modified: scintilla/lexilla/lexers/LexCIL.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -407,4 +407,4 @@ void SCI_METHOD LexerCIL::Fold(Sci_PositionU startPos, Sci_Position length, } }

-LexerModule lmCIL(SCLEX_CIL, LexerCIL::LexerFactoryCIL, "cil", cilWordListDesc); \ No newline at end of file +extern const LexerModule lmCIL(SCLEX_CIL, LexerCIL::LexerFactoryCIL, "cil", cilWordListDesc); \ No newline at end of file

Modified: scintilla/lexilla/lexers/LexCOBOL.cxx 262 lines changed, 135 insertions(+), 127 deletions(-) =================================================================== @@ -8,12 +8,11 @@ ** Updated by Rod Falck, Aug 2006 Converted to COBOL **/

-#include <stdlib.h> -#include <string.h> -#include <stdio.h> -#include <stdarg.h> -#include <assert.h> -#include <ctype.h> +#include <cstdlib> +#include <cassert> +#include <cstring> +#include <cctype> +#include <cstdio>

#include <string> #include <string_view> @@ -38,34 +37,36 @@ using namespace Lexilla; #define IN_FLAGS 0xF #define NOT_HEADER 0x10

-inline bool isCOBOLoperator(char ch) +namespace { + +bool isCOBOLoperator(char ch) { return isoperator(ch); }

-inline bool isCOBOLwordchar(char ch) +bool isCOBOLwordchar(char ch) { return IsASCII(ch) && (isalnum(ch) || ch == '-');

}

-inline bool isCOBOLwordstart(char ch) +bool isCOBOLwordstart(char ch) { return IsASCII(ch) && isalnum(ch); }

-static int CountBits(int nBits) - { - int count = 0; - for (int i = 0; i < 32; ++i) - { - count += nBits & 1; - nBits >>= 1; - } - return count; - } - -static void getRange(Sci_PositionU start, +int CountBits(int nBits) + { + int count = 0; + for (int i = 0; i < 32; ++i) + { + count += nBits & 1; + nBits >>= 1; + } + return count; + } + +void getRange(Sci_PositionU start, Sci_PositionU end, Accessor &styler, char *s, @@ -78,79 +79,79 @@ static void getRange(Sci_PositionU start, s[i] = '\0'; }

-static void ColourTo(Accessor &styler, Sci_PositionU end, unsigned int attr) { +void ColourTo(Accessor &styler, Sci_PositionU end, unsigned int attr) { styler.ColourTo(end, attr); }

-static int classifyWordCOBOL(Sci_PositionU start, Sci_PositionU end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, int nContainment, bool *bAarea) { +int classifyWordCOBOL(Sci_PositionU start, Sci_PositionU end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, int nContainment, bool *bAarea) { int ret = 0;

- WordList& a_keywords = *keywordlists[0]; - WordList& b_keywords = *keywordlists[1]; - WordList& c_keywords = *keywordlists[2]; - char s[100]; s[0] = '\0'; s[1] = '\0'; getRange(start, end, styler, s, sizeof(s));

- char chAttr = SCE_C_IDENTIFIER; + int chAttr = SCE_COBOL_IDENTIFIER; if (isdigit(s[0]) || (s[0] == '.') || (s[0] == 'v')) { - chAttr = SCE_C_NUMBER; - char *p = s + 1; - while (*p) { - if ((!isdigit(*p) && (*p) != 'v') && isCOBOLwordchar(*p)) { - chAttr = SCE_C_IDENTIFIER; - break; - } - ++p; - } + chAttr = SCE_COBOL_NUMBER; + char *p = s + 1; + while (*p) { + if ((!isdigit(*p) && (*p) != 'v') && isCOBOLwordchar(*p)) { + chAttr = SCE_COBOL_IDENTIFIER; + break; + } + ++p; + } } - else { + if (chAttr == SCE_COBOL_IDENTIFIER) { + WordList& a_keywords = *keywordlists[0]; + WordList& b_keywords = *keywordlists[1]; + WordList& c_keywords = *keywordlists[2]; + if (a_keywords.InList(s)) { - chAttr = SCE_C_WORD; + chAttr = SCE_COBOL_WORD; } else if (b_keywords.InList(s)) { - chAttr = SCE_C_WORD2; + chAttr = SCE_COBOL_WORD2; } else if (c_keywords.InList(s)) { - chAttr = SCE_C_UUID; + chAttr = SCE_COBOL_WORD3; } } if (*bAarea) { if (strcmp(s, "division") == 0) { ret = IN_DIVISION; - // we've determined the containment, anything else is just ignored for those purposes - *bAarea = false; - } else if (strcmp(s, "declaratives") == 0) { + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "declaratives") == 0) { ret = IN_DIVISION | IN_DECLARATIVES; - if (nContainment & IN_DECLARATIVES) - ret |= NOT_HEADER | IN_SECTION; - // we've determined the containment, anything else is just ignored for those purposes - *bAarea = false; - } else if (strcmp(s, "section") == 0) { + if (nContainment & IN_DECLARATIVES) + ret |= NOT_HEADER | IN_SECTION; + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "section") == 0) { ret = (nContainment &~ IN_PARAGRAPH) | IN_SECTION; - // we've determined the containment, anything else is just ignored for those purposes - *bAarea = false; - } else if (strcmp(s, "end") == 0 && (nContainment & IN_DECLARATIVES)) { + // we've determined the containment, anything else is just ignored for those purposes + *bAarea = false; + } else if (strcmp(s, "end") == 0 && (nContainment & IN_DECLARATIVES)) { ret = IN_DIVISION | IN_DECLARATIVES | IN_SECTION | NOT_HEADER; - } else { - ret = nContainment | IN_PARAGRAPH; + } else { + ret = nContainment | IN_PARAGRAPH; } } ColourTo(styler, end, chAttr); return ret; }

-static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], +void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler) {

styler.StartAt(startPos);

int state = initStyle; - if (state == SCE_C_CHARACTER) // Does not leak onto next line - state = SCE_C_DEFAULT; + if (state == SCE_COBOL_CHARACTER) // Does not leak onto next line + state = SCE_COBOL_DEFAULT; char chPrev = ' '; char chNext = styler[startPos]; Sci_PositionU lengthDoc = startPos + length; @@ -161,7 +162,7 @@ static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int i if (currentLine > 0) { styler.SetLineState(currentLine, styler.GetLineState(currentLine-1)); nContainment = styler.GetLineState(currentLine); - nContainment &= ~NOT_HEADER; + nContainment &= ~NOT_HEADER; } else { styler.SetLineState(currentLine, 0); nContainment = 0; @@ -170,34 +171,34 @@ static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int i styler.StartSegment(startPos); bool bNewLine = true; bool bAarea = !isspacechar(chNext); - int column = 0; + int column = 0; for (Sci_PositionU i = startPos; i < lengthDoc; i++) { char ch = chNext;

chNext = styler.SafeGetCharAt(i + 1);

- ++column; + ++column;

if (bNewLine) { - column = 0; + column = 0; + } + if (column <= 1 && !bAarea) { + bAarea = !isspacechar(ch); } - if (column <= 1 && !bAarea) { - bAarea = !isspacechar(ch); - } bool bSetNewLine = false; if ((ch == '\r' && chNext != '\n') || (ch == '\n')) { // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix) // Avoid triggering two times on Dos/Win // End of line - if (state == SCE_C_CHARACTER) { + if (state == SCE_COBOL_CHARACTER) { ColourTo(styler, i, state); - state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; } styler.SetLineState(currentLine, nContainment); currentLine++; bSetNewLine = true; - if (nContainment & NOT_HEADER) - nContainment &= ~(NOT_HEADER | IN_DECLARATIVES | IN_SECTION); + if (nContainment & NOT_HEADER) + nContainment &= ~(NOT_HEADER | IN_DECLARATIVES | IN_SECTION); }

if (styler.IsLeadByte(ch)) { @@ -207,44 +208,44 @@ static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int i continue; }

- if (state == SCE_C_DEFAULT) { + if (state == SCE_COBOL_DEFAULT) { if (isCOBOLwordstart(ch) || (ch == '$' && IsASCII(chNext) && isalpha(chNext))) { ColourTo(styler, i-1, state); - state = SCE_C_IDENTIFIER; - } else if (column == 6 && ch == '*') { + state = SCE_COBOL_IDENTIFIER; + } else if (column == 6 && (ch == '*' || ch == '/')) { // Cobol comment line: asterisk in column 7. ColourTo(styler, i-1, state); - state = SCE_C_COMMENTLINE; + state = SCE_COBOL_COMMENTLINE; } else if (ch == '*' && chNext == '>') { // Cobol inline comment: asterisk, followed by greater than. ColourTo(styler, i-1, state); - state = SCE_C_COMMENTLINE; + state = SCE_COBOL_COMMENTLINE; } else if (column == 0 && ch == '*' && chNext != '*') { ColourTo(styler, i-1, state); - state = SCE_C_COMMENTLINE; + state = SCE_COBOL_COMMENTLINE; } else if (column == 0 && ch == '/' && chNext != '*') { ColourTo(styler, i-1, state); - state = SCE_C_COMMENTLINE; + state = SCE_COBOL_COMMENTLINE; } else if (column == 0 && ch == '*' && chNext == '*') { ColourTo(styler, i-1, state); - state = SCE_C_COMMENTDOC; + state = SCE_COBOL_COMMENTDOC; } else if (column == 0 && ch == '/' && chNext == '*') { ColourTo(styler, i-1, state); - state = SCE_C_COMMENTDOC; + state = SCE_COBOL_COMMENTDOC; } else if (ch == '"') { ColourTo(styler, i-1, state); - state = SCE_C_STRING; + state = SCE_COBOL_STRING; } else if (ch == ''') { ColourTo(styler, i-1, state); - state = SCE_C_CHARACTER; + state = SCE_COBOL_CHARACTER; } else if (ch == '?' && column == 0) { ColourTo(styler, i-1, state); - state = SCE_C_PREPROCESSOR; + state = SCE_COBOL_PREPROCESSOR; } else if (isCOBOLoperator(ch)) { ColourTo(styler, i-1, state); - ColourTo(styler, i, SCE_C_OPERATOR); + ColourTo(styler, i, SCE_COBOL_OPERATOR); } - } else if (state == SCE_C_IDENTIFIER) { + } else if (state == SCE_COBOL_IDENTIFIER) { if (!isCOBOLwordchar(ch)) { int lStateChange = classifyWordCOBOL(styler.GetStartSegment(), i - 1, keywordlists, styler, nContainment, &bAarea);

@@ -253,64 +254,69 @@ static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int i nContainment = lStateChange; }

- state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; chNext = styler.SafeGetCharAt(i + 1); - if (ch == '"') { - state = SCE_C_STRING; + if (column == 6 && (ch == '*' || ch == '/')) { + state = SCE_COBOL_COMMENTLINE; + } else if (ch == '"') { + state = SCE_COBOL_STRING; } else if (ch == ''') { - state = SCE_C_CHARACTER; + state = SCE_COBOL_CHARACTER; } else if (isCOBOLoperator(ch)) { - ColourTo(styler, i, SCE_C_OPERATOR); + ColourTo(styler, i, SCE_COBOL_OPERATOR); } } } else { - if (state == SCE_C_PREPROCESSOR) { + if (state == SCE_COBOL_PREPROCESSOR) { if ((ch == '\r' || ch == '\n') && !(chPrev == '\' || chPrev == '\r')) { ColourTo(styler, i-1, state); - state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; } - } else if (state == SCE_C_COMMENT) { + } else if (state == SCE_COBOL_COMMENT) { if (ch == '\r' || ch == '\n') { - ColourTo(styler, i, state); - state = SCE_C_DEFAULT; + ColourTo(styler, i-1, state); + state = SCE_COBOL_DEFAULT; } - } else if (state == SCE_C_COMMENTDOC) { + } else if (state == SCE_COBOL_COMMENTDOC) { if (ch == '\r' || ch == '\n') { if (((i > styler.GetStartSegment() + 2) || ( - (initStyle == SCE_C_COMMENTDOC) && + (initStyle == SCE_COBOL_COMMENTDOC) && (styler.GetStartSegment() == static_cast<Sci_PositionU>(startPos))))) { - ColourTo(styler, i, state); - state = SCE_C_DEFAULT; + ColourTo(styler, i-1, state); + state = SCE_COBOL_DEFAULT; } } - } else if (state == SCE_C_COMMENTLINE) { + } else if (state == SCE_COBOL_COMMENTLINE) { if (ch == '\r' || ch == '\n') { ColourTo(styler, i-1, state); - state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; } - } else if (state == SCE_C_STRING) { + } else if (state == SCE_COBOL_STRING) { if (ch == '"') { ColourTo(styler, i, state); - state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; + } else if (ch == '\r' || ch == '\n') { + ColourTo(styler, i-1, state); + state = SCE_COBOL_DEFAULT; } - } else if (state == SCE_C_CHARACTER) { + } else if (state == SCE_COBOL_CHARACTER) { if (ch == ''') { ColourTo(styler, i, state); - state = SCE_C_DEFAULT; + state = SCE_COBOL_DEFAULT; } } } chPrev = ch; bNewLine = bSetNewLine; - if (bNewLine) - { - bAarea = false; - } + if (bNewLine) + { + bAarea = false; + } } ColourTo(styler, lengthDoc - 1, state); }

-static void FoldCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], +void FoldCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) { bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0; Sci_PositionU endPos = startPos + length; @@ -321,41 +327,41 @@ static void FoldCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int, WordL

bool bNewLine = true; bool bAarea = !isspacechar(chNext); - int column = 0; - bool bComment = false; + int column = 0; + bool bComment = false; for (Sci_PositionU i = startPos; i < endPos; i++) { char ch = chNext; chNext = styler.SafeGetCharAt(i + 1); - ++column; + ++column;

if (bNewLine) { - column = 0; - bComment = (ch == '*' || ch == '/' || ch == '?'); + column = 0; + bComment = (ch == '*' || ch == '/' || ch == '?'); + } + if (column <= 1 && !bAarea) { + bAarea = !isspacechar(ch); } - if (column <= 1 && !bAarea) { - bAarea = !isspacechar(ch); - } bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n'); if (atEOL) { - int nContainment = styler.GetLineState(lineCurrent); + int nContainment = styler.GetLineState(lineCurrent); int lev = CountBits(nContainment & IN_FLAGS) | SC_FOLDLEVELBASE; - if (bAarea && !bComment) - --lev; + if (bAarea && !bComment) + --lev; if (visibleChars == 0 && foldCompact) lev |= SC_FOLDLEVELWHITEFLAG; if ((bAarea) && (visibleChars > 0) && !(nContainment & NOT_HEADER) && !bComment) lev |= SC_FOLDLEVELHEADERFLAG; if (lev != styler.LevelAt(lineCurrent)) { styler.SetLevel(lineCurrent, lev); } - if ((lev & SC_FOLDLEVELNUMBERMASK) <= (levelPrev & SC_FOLDLEVELNUMBERMASK)) { - // this level is at the same level or less than the previous line - // therefore these is nothing for the previous header to collapse, so remove the header - styler.SetLevel(lineCurrent - 1, levelPrev & ~SC_FOLDLEVELHEADERFLAG); - } + if ((lev & SC_FOLDLEVELNUMBERMASK) <= (levelPrev & SC_FOLDLEVELNUMBERMASK)) { + // this level is at the same level or less than the previous line + // therefore these is nothing for the previous header to collapse, so remove the header + styler.SetLevel(lineCurrent - 1, levelPrev & ~SC_FOLDLEVELHEADERFLAG); + } levelPrev = lev; visibleChars = 0; - bAarea = false; + bAarea = false; bNewLine = true; lineCurrent++; } else { @@ -372,11 +378,13 @@ static void FoldCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int, WordL styler.SetLevel(lineCurrent, levelPrev | flagsNext); }

-static const char * const COBOLWordListDesc[] = { +const char * const COBOLWordListDesc[] = { "A Keywords", "B Keywords", "Extended Keywords", - 0 + nullptr };

-LexerModule lmCOBOL(SCLEX_COBOL, ColouriseCOBOLDoc, "COBOL", FoldCOBOLDoc, COBOLWordListDesc); +} + +extern const LexerModule lmCOBOL(SCLEX_COBOL, ColouriseCOBOLDoc, "COBOL", FoldCOBOLDoc, COBOLWordListDesc);

Modified: scintilla/lexilla/lexers/LexCPP.cxx 313 lines changed, 183 insertions(+), 130 deletions(-) =================================================================== @@ -87,17 +87,13 @@ bool followsReturnKeyword(const StyleContext &sc, LexAccessor &styler) { return !*s; }

-constexpr bool IsSpaceOrTab(int ch) noexcept { - return ch == ' ' || ch == '\t'; -} - constexpr bool IsOperatorOrSpace(int ch) noexcept { return isoperator(ch) || IsASpace(ch); }

-bool OnlySpaceOrTab(const std::string &s) noexcept { +bool OnlySpaceOrTab(std::string_view s) noexcept { for (const char ch : s) { - if (!IsSpaceOrTab(ch)) + if (!IsASpaceOrTab(ch)) return false; } return true; @@ -141,7 +137,7 @@ BracketPair FindBracketPair(Tokens &tokens) { }

void highlightTaskMarker(StyleContext &sc, LexAccessor &styler, - int activity, const WordList &markerList, bool caseSensitive){ + int activity, const WordList &markerList, bool caseSensitive) { if (IsOperatorOrSpace(sc.chPrev) && !IsOperatorOrSpace(sc.ch) && markerList.Length()) { std::string marker; for (Sci_PositionU currPos = sc.currentPos; true; currPos++) { @@ -160,16 +156,19 @@ void highlightTaskMarker(StyleContext &sc, LexAccessor &styler, } }

+const CharacterSet setHexDigits(CharacterSet::setDigits, "ABCDEFabcdef"); +const CharacterSet setOctDigits("01234567"); +const CharacterSet setNoneNumeric; + class EscapeSequence { - const CharacterSet setHexDigits = CharacterSet(CharacterSet::setDigits, "ABCDEFabcdef"); - const CharacterSet setOctDigits = CharacterSet("01234567"); - const CharacterSet setNoneNumeric; const CharacterSet *escapeSetValid = nullptr; int digitsLeft = 0; public: + int outerState = SCE_C_DEFAULT; EscapeSequence() = default; - void resetEscapeState(int nextChar) noexcept { + void resetEscapeState(int state, int nextChar) noexcept { digitsLeft = 0; + outerState = state; escapeSetValid = &setNoneNumeric; if (nextChar == 'U') { digitsLeft = 9; @@ -185,7 +184,7 @@ class EscapeSequence { escapeSetValid = &setOctDigits; } } - bool atEscapeEnd(int currChar) const noexcept { + [[nodiscard]] bool atEscapeEnd(int currChar) const noexcept { return (digitsLeft <= 0) || !escapeSetValid->Contains(currChar); } void consumeDigit() noexcept { @@ -233,7 +232,7 @@ struct PPDefinition { std::string value; bool isUndef; std::string arguments; - PPDefinition(Sci_Position line_, const std::string &key_, const std::string &value_, bool isUndef_ = false, const std::string &arguments_="") : + PPDefinition(Sci_Position line_, std::string_view key_, std::string_view value_, bool isUndef_, std::string_view arguments_) : line(line_), key(key_), value(value_), isUndef(isUndef_), arguments(arguments_) { } }; @@ -254,28 +253,27 @@ class LinePPState { // level is the nesting level of #if constructs int level = -1; static const int maximumNestingLevel = 31; - int maskLevel() const noexcept { + [[nodiscard]] int maskLevel() const noexcept { if (level >= 0) { return 1 << level; - } else { - return 1; } + return 1; } public: LinePPState() noexcept = default; - bool ValidLevel() const noexcept { + [[nodiscard]] bool ValidLevel() const noexcept { return level >= 0 && level < maximumNestingLevel; } - bool IsActive() const noexcept { + [[nodiscard]] bool IsActive() const noexcept { return state == 0; } - bool IsInactive() const noexcept { + [[nodiscard]] bool IsInactive() const noexcept { return state != 0; } - int ActiveState() const noexcept { + [[nodiscard]] int ActiveState() const noexcept { return state ? inactiveFlag : 0; } - bool CurrentIfTaken() const noexcept { + [[nodiscard]] bool CurrentIfTaken() const noexcept { return (ifTaken & maskLevel()) != 0; } void StartSection(bool on) noexcept { @@ -310,7 +308,7 @@ class LinePPState { class PPStates { std::vector<LinePPState> vlls; public: - LinePPState ForLine(Sci_Position line) const noexcept { + [[nodiscard]] LinePPState ForLine(Sci_Position line) const noexcept { if ((line > 0) && (vlls.size() > static_cast<size_t>(line))) { return vlls[line]; } @@ -322,6 +320,68 @@ class PPStates { } };

+enum class BackQuotedString : int { + None, + RawString, + TemplateLiteral, +}; + +// string interpolating state +struct InterpolatingState { + int state; + int braceCount; +}; + +struct Definition { + std::string_view name; + std::string_view value; + std::string_view arguments; +}; + +constexpr std::string_view TrimSpaceTab(std::string_view sv) noexcept { + while (!sv.empty() && IsASpaceOrTab(sv.front())) { + sv.remove_prefix(1); + } + return sv; +} + +// Parse a macro definition, either from a #define line in a file or from keywords. +// Either an object macro <NAME> <VALUE> or a function macro <NAME>(<ARGUMENTS>) <VALUE>. +// VALUE is optional and is treated as "1" if missing. +// #define ALLOW_PRINT +// #define VERSION 37 +// #define VER(a,b) a*10+b +// Whitespace separates macro and value in files but keywords use '=' separator. +// 'endName' contains a set of characters that terminate the name of the macro. + +constexpr Definition ParseDefine(std::string_view definition, std::string_view endName) { + Definition ret; + definition = TrimSpaceTab(definition); + const size_t afterName = definition.find_first_of(endName); + if (afterName != std::string_view::npos) { + ret.name = definition.substr(0, afterName); + if (definition.at(afterName) == '(') { + // Macro + definition.remove_prefix(afterName+1); + const size_t closeBracket = definition.find(')'); + if (closeBracket != std::string_view::npos) { + ret.arguments = definition.substr(0, closeBracket); + definition.remove_prefix(closeBracket+1); + if (!definition.empty() && (endName.find(definition.front()) != std::string_view::npos)) { + definition.remove_prefix(1); + } + ret.value = definition; + } // else malformed as requires closing bracket + } else { + ret.value = definition.substr(afterName+1); + } + } else { + ret.name = definition; + ret.value = "1"; + } + return ret; +} + // An individual named option for use in an OptionSet

// Options used for LexerCPP @@ -333,7 +393,7 @@ struct OptionsCPP { bool verbatimStringsAllowEscapes = false; bool triplequotedStrings = false; bool hashquotedStrings = false; - bool backQuotedStrings = false; + BackQuotedString backQuotedStrings = BackQuotedString::None; bool escapeSequence = false; bool fold = false; bool foldSyntaxBased = true; @@ -385,7 +445,10 @@ struct OptionSetCPP : public OptionSet<OptionsCPP> { "Set to 1 to enable highlighting of hash-quoted strings.");

DefineProperty("lexer.cpp.backquoted.strings", &OptionsCPP::backQuotedStrings, - "Set to 1 to enable highlighting of back-quoted raw strings ."); + "Set how to highlighting back-quoted strings. " + "0 (the default) no highlighting. " + "1 highlighted as Go raw string. " + "2 highlighted as JavaScript template literal.");

DefineProperty("lexer.cpp.escape.sequence", &OptionsCPP::escapeSequence, "Set to 1 to enable highlighting of escape sequences in strings"); @@ -480,6 +543,7 @@ class LexerCPP : public ILexer5 { CharacterSet setWordStart; PPStates vlls; std::vector<PPDefinition> ppDefineHistory; + std::map<Sci_Position, std::vector<InterpolatingState>> interpolatingAtEol; WordList keywords; WordList keywords2; WordList keywords3; @@ -490,25 +554,25 @@ class LexerCPP : public ILexer5 { std::string value; std::string arguments; SymbolValue() noexcept = default; - SymbolValue(const std::string &value_, const std::string &arguments_) : value(value_), arguments(arguments_) { + SymbolValue(std::string_view value_, std::string_view arguments_) : value(value_), arguments(arguments_) { } SymbolValue &operator = (const std::string &value_) { value = value_; arguments.clear(); return *this; } - bool IsMacro() const noexcept { + [[nodiscard]] bool IsMacro() const noexcept { return !arguments.empty(); } }; - typedef std::map<std::string, SymbolValue> SymbolTable; + using SymbolTable = std::map<std::string, SymbolValue>; SymbolTable preprocessorDefinitionsStart; OptionsCPP options; OptionSetCPP osCPP; EscapeSequence escapeSeq; SparseStatestd::string rawStringTerminators; enum { ssIdentifier, ssDocKeyword }; - SubStyles subStyles; + SubStyles subStyles{ styleSubable, SubStylesFirst, SubStylesAvailable, inactiveFlag }; std::string returnBuffer; public: explicit LexerCPP(bool caseSensitive_) : @@ -518,40 +582,38 @@ class LexerCPP : public ILexer5 { setAddOp("+-"), setMultOp("*/%"), setRelOp("=!<>"), - setLogicalOp("|&"), - subStyles(styleSubable, 0x80, 0x40, inactiveFlag) { + setLogicalOp("|&") { } // Deleted so LexerCPP objects can not be copied. LexerCPP(const LexerCPP &) = delete; LexerCPP(LexerCPP &&) = delete; void operator=(const LexerCPP &) = delete; void operator=(LexerCPP &&) = delete; - virtual ~LexerCPP() { - } + virtual ~LexerCPP() = default; void SCI_METHOD Release() noexcept override { delete this; } int SCI_METHOD Version() const noexcept override { return lvRelease5; } - const char * SCI_METHOD PropertyNames() override { + const char *SCI_METHOD PropertyNames() override { return osCPP.PropertyNames(); } int SCI_METHOD PropertyType(const char *name) override { return osCPP.PropertyType(name); } - const char * SCI_METHOD DescribeProperty(const char *name) override { + const char *SCI_METHOD DescribeProperty(const char *name) override { return osCPP.DescribeProperty(name); } Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override; - const char * SCI_METHOD DescribeWordListSets() override { + const char *SCI_METHOD DescribeWordListSets() override { return osCPP.DescribeWordListSets(); } Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override; void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override; void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;

- void * SCI_METHOD PrivateCall(int, void *) noexcept override { + void *SCI_METHOD PrivateCall(int, void *) noexcept override { return nullptr; }

@@ -585,23 +647,23 @@ class LexerCPP : public ILexer5 { int SCI_METHOD DistanceToSecondaryStyles() noexcept override { return inactiveFlag; } - const char * SCI_METHOD GetSubStyleBases() noexcept override { + const char *SCI_METHOD GetSubStyleBases() noexcept override { return styleSubable; } int SCI_METHOD NamedStyles() override { return std::max(subStyles.LastAllocated() + 1, sizeLexicalClasses) + inactiveFlag; } - const char * SCI_METHOD NameOfStyle(int style) override { + const char *SCI_METHOD NameOfStyle(int style) override { if (style >= NamedStyles()) return ""; if (style < sizeLexicalClasses) return lexicalClasses[style].name; // TODO: inactive and substyles return ""; } - const char * SCI_METHOD TagsOfStyle(int style) override { + const char *SCI_METHOD TagsOfStyle(int style) override { if (style >= NamedStyles()) return "Excess"; returnBuffer.clear(); @@ -633,7 +695,7 @@ class LexerCPP : public ILexer5 { } return ""; } - const char * SCI_METHOD DescriptionOfStyle(int style) override { + const char *SCI_METHOD DescriptionOfStyle(int style) override { if (style >= NamedStyles()) return ""; if (style < sizeLexicalClasses) @@ -643,13 +705,13 @@ class LexerCPP : public ILexer5 { }

// ILexer5 methods - const char * SCI_METHOD GetName() override { + const char *SCI_METHOD GetName() override { return caseSensitive ? "cpp" : "cppnocase"; } int SCI_METHOD GetIdentifier() override { return caseSensitive ? SCLEX_CPP : SCLEX_CPPNOCASE; } - const char * SCI_METHOD PropertyGet(const char *key) override; + const char *SCI_METHOD PropertyGet(const char *key) override;

static ILexer5 *LexerFactoryCPP() { return new LexerCPP(true); @@ -661,7 +723,7 @@ class LexerCPP : public ILexer5 { return style & ~inactiveFlag; } void EvaluateTokens(Tokens &tokens, const SymbolTable &preprocessorDefinitions); - Tokens Tokenize(const std::string &expr) const; + [[nodiscard]] Tokens Tokenize(const std::string &expr) const; bool EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions); };

@@ -678,7 +740,7 @@ Sci_Position SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) return -1; }

-const char * SCI_METHOD LexerCPP::PropertyGet(const char *key) { +const char *SCI_METHOD LexerCPP::PropertyGet(const char *key) { return osCPP.PropertyGet(key); }

@@ -714,26 +776,8 @@ Sci_Position SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) { // Rebuild preprocessorDefinitions preprocessorDefinitionsStart.clear(); for (int nDefinition = 0; nDefinition < ppDefinitions.Length(); nDefinition++) { - const char *cpDefinition = ppDefinitions.WordAt(nDefinition); - const char *cpEquals = strchr(cpDefinition, '='); - if (cpEquals) { - std::string name(cpDefinition, cpEquals - cpDefinition); - std::string val(cpEquals+1); - const size_t bracket = name.find('('); - const size_t bracketEnd = name.find(')'); - if ((bracket != std::string::npos) && (bracketEnd != std::string::npos)) { - // Macro - std::string args = name.substr(bracket + 1, bracketEnd - bracket - 1); - name = name.substr(0, bracket); - preprocessorDefinitionsStart[name] = SymbolValue(val, args); - } else { - preprocessorDefinitionsStart[name] = val; - } - } else { - std::string name(cpDefinition); - std::string val("1"); - preprocessorDefinitionsStart[name] = val; - } + const Definition def = ParseDefine(ppDefinitions.WordAt(nDefinition), "(="); + preprocessorDefinitionsStart[std::string(def.name)] = SymbolValue(def.value, def.arguments); } } } @@ -747,7 +791,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i const StyleContext::Transform transform = caseSensitive ? StyleContext::Transform::none : StyleContext::Transform::lower;

- const CharacterSet setOKBeforeRE("([{=,:;!%^&*|?~+-"); + const CharacterSet setOKBeforeRE("([{=,:;!%^&*|?~+-> "); const CharacterSet setCouldBePostOp("+-");

const CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\&<>#{}[]"); @@ -771,7 +815,21 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i bool inRERange = false; bool seenDocKeyBrace = false;

+ std::vector<InterpolatingState> interpolatingStack; + Sci_Position lineCurrent = styler.GetLine(startPos); + if (options.backQuotedStrings == BackQuotedString::TemplateLiteral) { + // code copied from LexPython + auto it = interpolatingAtEol.find(lineCurrent - 1); + if (it != interpolatingAtEol.end()) { + interpolatingStack = it->second; + } + it = interpolatingAtEol.lower_bound(lineCurrent); + if (it != interpolatingAtEol.end()) { + interpolatingAtEol.erase(it, interpolatingAtEol.end()); + } + } + if ((MaskActive(initStyle) == SCE_C_PREPROCESSOR) || (MaskActive(initStyle) == SCE_C_COMMENTLINE) || (MaskActive(initStyle) == SCE_C_COMMENTLINEDOC)) { @@ -832,6 +890,12 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i

Sci_PositionU lineEndNext = styler.LineEnd(lineCurrent);

+ if (sc.currentPos == 0 && sc.Match('#', '!')) { + // Shell Shebang at beginning of file + sc.SetState(SCE_C_COMMENTLINE); + sc.Forward(); + } + for (; sc.More();) {

if (sc.atLineStart) { @@ -864,6 +928,9 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i if (!rawStringTerminator.empty()) { rawSTNew.Set(lineCurrent-1, rawStringTerminator); } + if (!interpolatingStack.empty()) { + interpolatingAtEol[sc.currentLine] = interpolatingStack; + } }

// Handle line continuation generically. @@ -899,8 +966,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i sc.ChangeState(SCE_C_USERLITERAL|activitySet); } else if (!(setWord.Contains(sc.ch) || (sc.ch == ''') - || ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E' || - sc.chPrev == 'p' || sc.chPrev == 'P')))) { + || (AnyOf(sc.chPrev, 'e', 'E', 'p', 'P') && AnyOf(sc.ch, '+', '-')))) { sc.SetState(SCE_C_DEFAULT|activitySet); } break; @@ -1007,7 +1073,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i styleBeforeDCKeyword = SCE_C_COMMENTDOC; sc.SetState(SCE_C_COMMENTDOCKEYWORD|activitySet); } - } else if ((sc.ch == '<' && sc.chNext != '/') + } else if ((sc.ch == '<' && !(IsASpace(sc.chNext) || sc.chNext == '/')) || (sc.ch == '/' && sc.chPrev == '<')) { // XML comment style styleBeforeDCKeyword = SCE_C_COMMENTDOC; sc.ForwardSetState(SCE_C_COMMENTDOCKEYWORD | activitySet); @@ -1045,13 +1111,13 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i } else if (sc.ch == '[' || sc.ch == '{') { seenDocKeyBrace = true; } else if (!setDoxygen.Contains(sc.ch) - && !(seenDocKeyBrace && (sc.ch == ',' || sc.ch == '.'))) { + && !(seenDocKeyBrace && AnyOf(sc.ch, ',', '.'))) { if (!(IsASpace(sc.ch) || (sc.ch == 0))) { sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR|activitySet); } else { sc.GetCurrentString(currentText, transform); assert(!currentText.empty()); - std::string currentSuffix = currentText.substr(1); + const std::string currentSuffix = currentText.substr(1); if (!keywords3.InList(currentSuffix) && !keywords3.InList(currentText)) { const int subStyleCDKW = classifierDocKeyWords.ValueFor(currentSuffix); if (subStyleCDKW >= 0) { @@ -1087,8 +1153,8 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i } } else if (sc.ch == '\') { if (options.escapeSequence) { + escapeSeq.resetEscapeState(sc.state, sc.chNext); sc.SetState(SCE_C_ESCAPESEQUENCE|activitySet); - escapeSeq.resetEscapeState(sc.chNext); } sc.Forward(); // Skip all characters after the backslash } else if (sc.ch == '"') { @@ -1101,20 +1167,9 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i break; case SCE_C_ESCAPESEQUENCE: escapeSeq.consumeDigit(); - if (!escapeSeq.atEscapeEnd(sc.ch)) { - break; - } - if (sc.ch == '"') { - sc.SetState(SCE_C_STRING|activitySet); - sc.ForwardSetState(SCE_C_DEFAULT|activitySet); - } else if (sc.ch == '\') { - escapeSeq.resetEscapeState(sc.chNext); - sc.Forward(); - } else { - sc.SetState(SCE_C_STRING|activitySet); - if (sc.atLineEnd) { - sc.ChangeState(SCE_C_STRINGEOL|activitySet); - } + if (escapeSeq.atEscapeEnd(sc.ch)) { + sc.SetState(escapeSeq.outerState); + continue; } break; case SCE_C_HASHQUOTEDSTRING: @@ -1131,7 +1186,21 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i for (size_t termPos=rawStringTerminator.size(); termPos; termPos--) sc.Forward(); sc.SetState(SCE_C_DEFAULT|activitySet); - rawStringTerminator.clear(); + if (interpolatingStack.empty()) { + rawStringTerminator.clear(); + } + } else if (options.backQuotedStrings == BackQuotedString::TemplateLiteral) { + if (sc.ch == '\') { + if (options.escapeSequence) { + escapeSeq.resetEscapeState(sc.state, sc.chNext); + sc.SetState(SCE_C_ESCAPESEQUENCE|activitySet); + } + sc.Forward(); // Skip all characters after the backslash + } else if (sc.Match('$', '{')) { + interpolatingStack.push_back({sc.state, 1}); + sc.SetState(SCE_C_OPERATOR|activitySet); + sc.Forward(); + } } break; case SCE_C_CHARACTER: @@ -1222,7 +1291,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i } else if (options.hashquotedStrings && sc.Match('#', '"')) { sc.SetState(SCE_C_HASHQUOTEDSTRING|activitySet); sc.Forward(); - } else if (options.backQuotedStrings && sc.Match('`')) { + } else if ((options.backQuotedStrings != BackQuotedString::None) && sc.Match('`')) { sc.SetState(SCE_C_STRINGRAW|activitySet); rawStringTerminator = "`"; } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { @@ -1336,7 +1405,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i // Inactive, if expression true then may become active if parent scope active assert(sc.state == (SCE_C_PREPROCESSOR | inactiveFlag)); // Similar to #if - std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 4, true); + const std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 4, true); const bool ifGood = EvaluateExpression(restOfLine, preprocessorDefinitions); if (ifGood) { preproc.InvertCurrentLevel(); @@ -1358,41 +1427,11 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i sc.ChangeState(SCE_C_PREPROCESSOR|activitySet); } else if (sc.Match("define")) { if (options.updatePreprocessor && preproc.IsActive()) { - std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true); - size_t startName = 0; - while ((startName < restOfLine.length()) && IsSpaceOrTab(restOfLine[startName])) - startName++; - size_t endName = startName; - while ((endName < restOfLine.length()) && setWord.Contains(restOfLine[endName])) - endName++; - std::string key = restOfLine.substr(startName, endName-startName); - if ((endName < restOfLine.length()) && (restOfLine.at(endName) == '(')) { - // Macro - size_t endArgs = endName; - while ((endArgs < restOfLine.length()) && (restOfLine[endArgs] != ')')) - endArgs++; - std::string args = restOfLine.substr(endName + 1, endArgs - endName - 1); - size_t startValue = endArgs+1; - while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue])) - startValue++; - std::string value; - if (startValue < restOfLine.length()) - value = restOfLine.substr(startValue); - preprocessorDefinitions[key] = SymbolValue(value, args); - ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value, false, args)); - definitionsChanged = true; - } else { - // Value - size_t startValue = endName; - while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue])) - startValue++; - std::string value = restOfLine.substr(startValue); - if (OnlySpaceOrTab(value)) - value = "1"; // No value defaults to 1 - preprocessorDefinitions[key] = value; - ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value)); - definitionsChanged = true; - } + const std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true); + const Definition def = ParseDefine(restOfLine, "( \t"); + preprocessorDefinitions[std::string(def.name)] = SymbolValue(def.value, def.arguments); + ppDefineHistory.emplace_back(lineCurrent, def.name, def.value, false, def.arguments); + definitionsChanged = true; } } else if (sc.Match("undef")) { if (options.updatePreprocessor && preproc.IsActive()) { @@ -1401,7 +1440,7 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i if (!tokens.empty()) { const std::string key = tokens[0]; preprocessorDefinitions.erase(key); - ppDefineHistory.push_back(PPDefinition(lineCurrent, key, "", true)); + ppDefineHistory.emplace_back(lineCurrent, key, "", true, ""); definitionsChanged = true; } } @@ -1410,6 +1449,19 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci@@ Diff output truncated at 100000 characters. @@

-------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).