Refactor: CString optimizations

[TortoiseGit.git] / ext / scintilla / include / Scintilla.iface

## First line may be used for shbang\r
\r
## This file defines the interface to Scintilla\r
\r
## Copyright 2000-2003 by Neil Hodgson <neilh@scintilla.org>\r
## The License.txt file describes the conditions under which this software may be distributed.\r
\r
## A line starting with ## is a pure comment and should be stripped by readers.\r
## A line starting with #! is for future shbang use\r
## A line starting with # followed by a space is a documentation comment and refers\r
## to the next feature definition.\r
\r
## Each feature is defined by a line starting with fun, get, set, val or evt.\r
##     cat -> start a category\r
##     fun -> a function\r
##     get -> a property get function\r
##     set -> a property set function\r
##     val -> definition of a constant\r
##     evt -> an event\r
##     enu -> associate an enumeration with a set of vals with a prefix\r
##     lex -> associate a lexer with the lexical classes it produces\r
##\r
## All other feature names should be ignored. They may be defined in the future.\r
## A property may have a set function, a get function or both. Each will have\r
## "Get" or "Set" in their names and the corresponding name will have the obvious switch.\r
## A property may be subscripted, in which case the first parameter is the subscript.\r
## fun, get, and set features have a strict syntax:\r
## <featureType><ws><returnType><ws><name>[=<number](<param>,<param>)\r
## where <ws> stands for white space.\r
## param may be empty (null value) or is <paramType><ws><paramName>[=<value>]\r
## Additional white space is allowed between elements.\r
## The syntax for evt is <featureType><ws><returnType><ws><name>[=<number]([<param>[,<param>]*])\r
## Feature names that contain an underscore are defined by Windows, so in these\r
## cases, using the Windows definition is preferred where available.\r
## The feature numbers are stable so features will not be renumbered.\r
## Features may be removed but they will go through a period of deprecation\r
## before removal which is signalled by moving them into the Deprecated category.\r
##\r
## enu has the syntax enu<ws><enumeration>=<prefix>[<ws><prefix>]* where all the val\r
## features in this file starting with a given <prefix> are considered part of the\r
## enumeration.\r
##\r
## lex has the syntax lex<ws><name>=<lexerVal><ws><prefix>[<ws><prefix>]*\r
## where name is a reasonably capitalised (Python, XML) identifier or UI name,\r
## lexerVal is the val used to specify the lexer, and the list of prefixes is similar\r
## to enu. The name may not be the same as that used within the lexer so the lexerVal\r
## should be used to tie these entities together.\r
\r
## Types:\r
##     void\r
##     int\r
##     bool -> integer, 1=true, 0=false\r
##     position -> integer position in a document\r
##     colour -> colour integer containing red, green and blue bytes.\r
##     string -> pointer to const character\r
##     stringresult -> pointer to character, NULL-> return size of result\r
##     cells -> pointer to array of cells, each cell containing a style byte and character byte\r
##     textrange -> range of a min and a max position with an output string\r
##     findtext -> searchrange, text -> foundposition\r
##     keymod -> integer containing key in low half and modifiers in high half\r
##     formatrange\r
## Types no longer used:\r
##     findtextex -> searchrange\r
##     charrange -> range of a min and a max position\r
##     charrangeresult -> like charrange, but output param\r
##     countedstring\r
##     point -> x,y\r
##     pointresult  -> like point, but output param\r
##     rectangle -> left,top,right,bottom\r
## Client code should ignore definitions containing types it does not understand, except\r
## for possibly #defining the constants\r
\r
## Line numbers and positions start at 0.\r
## String arguments may contain NUL ('\0') characters where the calls provide a length\r
## argument and retrieve NUL characters. APIs marked as NUL-terminated also have a\r
## NUL appended but client code should calculate the size that will be returned rather\r
## than relying upon the NUL whenever possible. Allow for the extra NUL character when\r
## allocating buffers. The size to allocate for a stringresult (not including NUL) can be\r
## determined by calling with a NULL (0) pointer.\r
\r
cat Basics\r
\r
################################################\r
## For Scintilla.h\r
val INVALID_POSITION=-1\r
# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages\r
# as many EM_ messages can be used although that use is deprecated.\r
val SCI_START=2000\r
val SCI_OPTIONAL_START=3000\r
val SCI_LEXER_START=4000\r
\r
# Add text to the document at current position.\r
fun void AddText=2001(int length, string text)\r
\r
# Add array of cells to document.\r
fun void AddStyledText=2002(int length, cells c)\r
\r
# Insert string at a position.\r
fun void InsertText=2003(position pos, string text)\r
\r
# Change the text that is being inserted in response to SC_MOD_INSERTCHECK\r
fun void ChangeInsertion=2672(int length, string text)\r
\r
# Delete all text in the document.\r
fun void ClearAll=2004(,)\r
\r
# Delete a range of text in the document.\r
fun void DeleteRange=2645(position pos, int deleteLength)\r
\r
# Set all style bytes to 0, remove all folding information.\r
fun void ClearDocumentStyle=2005(,)\r
\r
# Returns the number of bytes in the document.\r
get int GetLength=2006(,)\r
\r
# Returns the character byte at the position.\r
get int GetCharAt=2007(position pos,)\r
\r
# Returns the position of the caret.\r
get position GetCurrentPos=2008(,)\r
\r
# Returns the position of the opposite end of the selection to the caret.\r
get position GetAnchor=2009(,)\r
\r
# Returns the style byte at the position.\r
get int GetStyleAt=2010(position pos,)\r
\r
# Redoes the next action on the undo history.\r
fun void Redo=2011(,)\r
\r
# Choose between collecting actions into the undo\r
# history and discarding them.\r
set void SetUndoCollection=2012(bool collectUndo,)\r
\r
# Select all the text in the document.\r
fun void SelectAll=2013(,)\r
\r
# Remember the current position in the undo history as the position\r
# at which the document was saved.\r
fun void SetSavePoint=2014(,)\r
\r
# Retrieve a buffer of cells.\r
# Returns the number of bytes in the buffer not including terminating NULs.\r
fun int GetStyledText=2015(, textrange tr)\r
\r
# Are there any redoable actions in the undo history?\r
fun bool CanRedo=2016(,)\r
\r
# Retrieve the line number at which a particular marker is located.\r
fun int MarkerLineFromHandle=2017(int handle,)\r
\r
# Delete a marker.\r
fun void MarkerDeleteHandle=2018(int handle,)\r
\r
# Is undo history being collected?\r
get bool GetUndoCollection=2019(,)\r
\r
enu WhiteSpace=SCWS_\r
val SCWS_INVISIBLE=0\r
val SCWS_VISIBLEALWAYS=1\r
val SCWS_VISIBLEAFTERINDENT=2\r
\r
# Are white space characters currently visible?\r
# Returns one of SCWS_* constants.\r
get int GetViewWS=2020(,)\r
\r
# Make white space characters invisible, always visible or visible outside indentation.\r
set void SetViewWS=2021(int viewWS,)\r
\r
# Find the position from a point within the window.\r
fun position PositionFromPoint=2022(int x, int y)\r
\r
# Find the position from a point within the window but return\r
# INVALID_POSITION if not close to text.\r
fun position PositionFromPointClose=2023(int x, int y)\r
\r
# Set caret to start of a line and ensure it is visible.\r
fun void GotoLine=2024(int line,)\r
\r
# Set caret to a position and ensure it is visible.\r
fun void GotoPos=2025(position pos,)\r
\r
# Set the selection anchor to a position. The anchor is the opposite\r
# end of the selection from the caret.\r
set void SetAnchor=2026(position posAnchor,)\r
\r
# Retrieve the text of the line containing the caret.\r
# Returns the index of the caret on the line.\r
# Result is NUL-terminated.\r
fun int GetCurLine=2027(int length, stringresult text)\r
\r
# Retrieve the position of the last correctly styled character.\r
get position GetEndStyled=2028(,)\r
\r
enu EndOfLine=SC_EOL_\r
val SC_EOL_CRLF=0\r
val SC_EOL_CR=1\r
val SC_EOL_LF=2\r
\r
# Convert all line endings in the document to one mode.\r
fun void ConvertEOLs=2029(int eolMode,)\r
\r
# Retrieve the current end of line mode - one of CRLF, CR, or LF.\r
get int GetEOLMode=2030(,)\r
\r
# Set the current end of line mode.\r
set void SetEOLMode=2031(int eolMode,)\r
\r
# Set the current styling position to pos and the styling mask to mask.\r
# The styling mask can be used to protect some bits in each styling byte from modification.\r
fun void StartStyling=2032(position pos, int mask)\r
\r
# Change style from current styling position for length characters to a style\r
# and move the current styling position to after this newly styled segment.\r
fun void SetStyling=2033(int length, int style)\r
\r
# Is drawing done first into a buffer or direct to the screen?\r
get bool GetBufferedDraw=2034(,)\r
\r
# If drawing is buffered then each line of text is drawn into a bitmap buffer\r
# before drawing it to the screen to avoid flicker.\r
set void SetBufferedDraw=2035(bool buffered,)\r
\r
# Change the visible size of a tab to be a multiple of the width of a space character.\r
set void SetTabWidth=2036(int tabWidth,)\r
\r
# Retrieve the visible size of a tab.\r
get int GetTabWidth=2121(,)\r
\r
# Clear explicit tabstops on a line.\r
fun void ClearTabStops=2675(int line,)\r
\r
# Add an explicit tab stop for a line.\r
fun void AddTabStop=2676(int line, int x)\r
\r
# Find the next explicit tab stop position on a line after a position.\r
fun int GetNextTabStop=2677(int line, int x)\r
\r
# The SC_CP_UTF8 value can be used to enter Unicode mode.\r
# This is the same value as CP_UTF8 in Windows\r
val SC_CP_UTF8=65001\r
\r
# Set the code page used to interpret the bytes of the document as characters.\r
# The SC_CP_UTF8 value can be used to enter Unicode mode.\r
set void SetCodePage=2037(int codePage,)\r
\r
enu IMEInteraction=SC_IME_\r
val SC_IME_WINDOWED=0\r
val SC_IME_INLINE=1\r
\r
# Is the IME displayed in a winow or inline?\r
get int GetIMEInteraction=2678(,)\r
\r
# Choose to display the the IME in a winow or inline.\r
set void SetIMEInteraction=2679(int imeInteraction,) \r
\r
enu MarkerSymbol=SC_MARK_\r
val MARKER_MAX=31\r
val SC_MARK_CIRCLE=0\r
val SC_MARK_ROUNDRECT=1\r
val SC_MARK_ARROW=2\r
val SC_MARK_SMALLRECT=3\r
val SC_MARK_SHORTARROW=4\r
val SC_MARK_EMPTY=5\r
val SC_MARK_ARROWDOWN=6\r
val SC_MARK_MINUS=7\r
val SC_MARK_PLUS=8\r
\r
# Shapes used for outlining column.\r
val SC_MARK_VLINE=9\r
val SC_MARK_LCORNER=10\r
val SC_MARK_TCORNER=11\r
val SC_MARK_BOXPLUS=12\r
val SC_MARK_BOXPLUSCONNECTED=13\r
val SC_MARK_BOXMINUS=14\r
val SC_MARK_BOXMINUSCONNECTED=15\r
val SC_MARK_LCORNERCURVE=16\r
val SC_MARK_TCORNERCURVE=17\r
val SC_MARK_CIRCLEPLUS=18\r
val SC_MARK_CIRCLEPLUSCONNECTED=19\r
val SC_MARK_CIRCLEMINUS=20\r
val SC_MARK_CIRCLEMINUSCONNECTED=21\r
\r
# Invisible mark that only sets the line background colour.\r
val SC_MARK_BACKGROUND=22\r
val SC_MARK_DOTDOTDOT=23\r
val SC_MARK_ARROWS=24\r
val SC_MARK_PIXMAP=25\r
val SC_MARK_FULLRECT=26\r
val SC_MARK_LEFTRECT=27\r
val SC_MARK_AVAILABLE=28\r
val SC_MARK_UNDERLINE=29\r
val SC_MARK_RGBAIMAGE=30\r
val SC_MARK_BOOKMARK=31\r
\r
val SC_MARK_CHARACTER=10000\r
\r
enu MarkerOutline=SC_MARKNUM_\r
# Markers used for outlining column.\r
val SC_MARKNUM_FOLDEREND=25\r
val SC_MARKNUM_FOLDEROPENMID=26\r
val SC_MARKNUM_FOLDERMIDTAIL=27\r
val SC_MARKNUM_FOLDERTAIL=28\r
val SC_MARKNUM_FOLDERSUB=29\r
val SC_MARKNUM_FOLDER=30\r
val SC_MARKNUM_FOLDEROPEN=31\r
\r
val SC_MASK_FOLDERS=0xFE000000\r
\r
# Set the symbol used for a particular marker number.\r
fun void MarkerDefine=2040(int markerNumber, int markerSymbol)\r
\r
# Set the foreground colour used for a particular marker number.\r
set void MarkerSetFore=2041(int markerNumber, colour fore)\r
\r
# Set the background colour used for a particular marker number.\r
set void MarkerSetBack=2042(int markerNumber, colour back)\r
\r
# Set the background colour used for a particular marker number when its folding block is selected.\r
set void MarkerSetBackSelected=2292(int markerNumber, colour back)\r
\r
# Enable/disable highlight for current folding bloc (smallest one that contains the caret)\r
fun void MarkerEnableHighlight=2293(bool enabled,)\r
\r
# Add a marker to a line, returning an ID which can be used to find or delete the marker.\r
fun int MarkerAdd=2043(int line, int markerNumber)\r
\r
# Delete a marker from a line.\r
fun void MarkerDelete=2044(int line, int markerNumber)\r
\r
# Delete all markers with a particular number from all lines.\r
fun void MarkerDeleteAll=2045(int markerNumber,)\r
\r
# Get a bit mask of all the markers set on a line.\r
fun int MarkerGet=2046(int line,)\r
\r
# Find the next line at or after lineStart that includes a marker in mask.\r
# Return -1 when no more lines.\r
fun int MarkerNext=2047(int lineStart, int markerMask)\r
\r
# Find the previous line before lineStart that includes a marker in mask.\r
fun int MarkerPrevious=2048(int lineStart, int markerMask)\r
\r
# Define a marker from a pixmap.\r
fun void MarkerDefinePixmap=2049(int markerNumber, string pixmap)\r
\r
# Add a set of markers to a line.\r
fun void MarkerAddSet=2466(int line, int set)\r
\r
# Set the alpha used for a marker that is drawn in the text area, not the margin.\r
set void MarkerSetAlpha=2476(int markerNumber, int alpha)\r
\r
val SC_MAX_MARGIN=4\r
\r
enu MarginType=SC_MARGIN_\r
val SC_MARGIN_SYMBOL=0\r
val SC_MARGIN_NUMBER=1\r
val SC_MARGIN_BACK=2\r
val SC_MARGIN_FORE=3\r
val SC_MARGIN_TEXT=4\r
val SC_MARGIN_RTEXT=5\r
\r
# Set a margin to be either numeric or symbolic.\r
set void SetMarginTypeN=2240(int margin, int marginType)\r
\r
# Retrieve the type of a margin.\r
get int GetMarginTypeN=2241(int margin,)\r
\r
# Set the width of a margin to a width expressed in pixels.\r
set void SetMarginWidthN=2242(int margin, int pixelWidth)\r
\r
# Retrieve the width of a margin in pixels.\r
get int GetMarginWidthN=2243(int margin,)\r
\r
# Set a mask that determines which markers are displayed in a margin.\r
set void SetMarginMaskN=2244(int margin, int mask)\r
\r
# Retrieve the marker mask of a margin.\r
get int GetMarginMaskN=2245(int margin,)\r
\r
# Make a margin sensitive or insensitive to mouse clicks.\r
set void SetMarginSensitiveN=2246(int margin, bool sensitive)\r
\r
# Retrieve the mouse click sensitivity of a margin.\r
get bool GetMarginSensitiveN=2247(int margin,)\r
\r
# Set the cursor shown when the mouse is inside a margin.\r
set void SetMarginCursorN=2248(int margin, int cursor)\r
\r
# Retrieve the cursor shown in a margin.\r
get int GetMarginCursorN=2249(int margin,)\r
\r
# Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles.\r
# Style 39 is for future use.\r
enu StylesCommon=STYLE_\r
val STYLE_DEFAULT=32\r
val STYLE_LINENUMBER=33\r
val STYLE_BRACELIGHT=34\r
val STYLE_BRACEBAD=35\r
val STYLE_CONTROLCHAR=36\r
val STYLE_INDENTGUIDE=37\r
val STYLE_CALLTIP=38\r
val STYLE_LASTPREDEFINED=39\r
val STYLE_MAX=255\r
\r
# Character set identifiers are used in StyleSetCharacterSet.\r
# The values are the same as the Windows *_CHARSET values.\r
enu CharacterSet=SC_CHARSET_\r
val SC_CHARSET_ANSI=0\r
val SC_CHARSET_DEFAULT=1\r
val SC_CHARSET_BALTIC=186\r
val SC_CHARSET_CHINESEBIG5=136\r
val SC_CHARSET_EASTEUROPE=238\r
val SC_CHARSET_GB2312=134\r
val SC_CHARSET_GREEK=161\r
val SC_CHARSET_HANGUL=129\r
val SC_CHARSET_MAC=77\r
val SC_CHARSET_OEM=255\r
val SC_CHARSET_RUSSIAN=204\r
val SC_CHARSET_CYRILLIC=1251\r
val SC_CHARSET_SHIFTJIS=128\r
val SC_CHARSET_SYMBOL=2\r
val SC_CHARSET_TURKISH=162\r
val SC_CHARSET_JOHAB=130\r
val SC_CHARSET_HEBREW=177\r
val SC_CHARSET_ARABIC=178\r
val SC_CHARSET_VIETNAMESE=163\r
val SC_CHARSET_THAI=222\r
val SC_CHARSET_8859_15=1000\r
\r
# Clear all the styles and make equivalent to the global default style.\r
fun void StyleClearAll=2050(,)\r
\r
# Set the foreground colour of a style.\r
set void StyleSetFore=2051(int style, colour fore)\r
\r
# Set the background colour of a style.\r
set void StyleSetBack=2052(int style, colour back)\r
\r
# Set a style to be bold or not.\r
set void StyleSetBold=2053(int style, bool bold)\r
\r
# Set a style to be italic or not.\r
set void StyleSetItalic=2054(int style, bool italic)\r
\r
# Set the size of characters of a style.\r
set void StyleSetSize=2055(int style, int sizePoints)\r
\r
# Set the font of a style.\r
set void StyleSetFont=2056(int style, string fontName)\r
\r
# Set a style to have its end of line filled or not.\r
set void StyleSetEOLFilled=2057(int style, bool filled)\r
\r
# Reset the default style to its state at startup\r
fun void StyleResetDefault=2058(,)\r
\r
# Set a style to be underlined or not.\r
set void StyleSetUnderline=2059(int style, bool underline)\r
\r
enu CaseVisible=SC_CASE_\r
val SC_CASE_MIXED=0\r
val SC_CASE_UPPER=1\r
val SC_CASE_LOWER=2\r
\r
# Get the foreground colour of a style.\r
get colour StyleGetFore=2481(int style,)\r
\r
# Get the background colour of a style.\r
get colour StyleGetBack=2482(int style,)\r
\r
# Get is a style bold or not.\r
get bool StyleGetBold=2483(int style,)\r
\r
# Get is a style italic or not.\r
get bool StyleGetItalic=2484(int style,)\r
\r
# Get the size of characters of a style.\r
get int StyleGetSize=2485(int style,)\r
\r
# Get the font of a style.\r
# Returns the length of the fontName\r
# Result is NUL-terminated.\r
get int StyleGetFont=2486(int style, stringresult fontName)\r
\r
# Get is a style to have its end of line filled or not.\r
get bool StyleGetEOLFilled=2487(int style,)\r
\r
# Get is a style underlined or not.\r
get bool StyleGetUnderline=2488(int style,)\r
\r
# Get is a style mixed case, or to force upper or lower case.\r
get int StyleGetCase=2489(int style,)\r
\r
# Get the character get of the font in a style.\r
get int StyleGetCharacterSet=2490(int style,)\r
\r
# Get is a style visible or not.\r
get bool StyleGetVisible=2491(int style,)\r
\r
# Get is a style changeable or not (read only).\r
# Experimental feature, currently buggy.\r
get bool StyleGetChangeable=2492(int style,)\r
\r
# Get is a style a hotspot or not.\r
get bool StyleGetHotSpot=2493(int style,)\r
\r
# Set a style to be mixed case, or to force upper or lower case.\r
set void StyleSetCase=2060(int style, int caseForce)\r
\r
val SC_FONT_SIZE_MULTIPLIER=100\r
\r
# Set the size of characters of a style. Size is in points multiplied by 100.\r
set void StyleSetSizeFractional=2061(int style, int caseForce)\r
\r
# Get the size of characters of a style in points multiplied by 100\r
get int StyleGetSizeFractional=2062(int style,)\r
\r
enu FontWeight=SC_WEIGHT_\r
val SC_WEIGHT_NORMAL=400\r
val SC_WEIGHT_SEMIBOLD=600\r
val SC_WEIGHT_BOLD=700\r
\r
# Set the weight of characters of a style.\r
set void StyleSetWeight=2063(int style, int weight)\r
\r
# Get the weight of characters of a style.\r
get int StyleGetWeight=2064(int style,)\r
\r
# Set the character set of the font in a style.\r
set void StyleSetCharacterSet=2066(int style, int characterSet)\r
\r
# Set a style to be a hotspot or not.\r
set void StyleSetHotSpot=2409(int style, bool hotspot)\r
\r
# Set the foreground colour of the main and additional selections and whether to use this setting.\r
fun void SetSelFore=2067(bool useSetting, colour fore)\r
\r
# Set the background colour of the main and additional selections and whether to use this setting.\r
fun void SetSelBack=2068(bool useSetting, colour back)\r
\r
# Get the alpha of the selection.\r
get int GetSelAlpha=2477(,)\r
\r
# Set the alpha of the selection.\r
set void SetSelAlpha=2478(int alpha,)\r
\r
# Is the selection end of line filled?\r
get bool GetSelEOLFilled=2479(,)\r
\r
# Set the selection to have its end of line filled or not.\r
set void SetSelEOLFilled=2480(bool filled,)\r
\r
# Set the foreground colour of the caret.\r
set void SetCaretFore=2069(colour fore,)\r
\r
# When key+modifier combination km is pressed perform msg.\r
fun void AssignCmdKey=2070(keymod km, int msg)\r
\r
# When key+modifier combination km is pressed do nothing.\r
fun void ClearCmdKey=2071(keymod km,)\r
\r
# Drop all key mappings.\r
fun void ClearAllCmdKeys=2072(,)\r
\r
# Set the styles for a segment of the document.\r
fun void SetStylingEx=2073(int length, string styles)\r
\r
# Set a style to be visible or not.\r
set void StyleSetVisible=2074(int style, bool visible)\r
\r
# Get the time in milliseconds that the caret is on and off.\r
get int GetCaretPeriod=2075(,)\r
\r
# Get the time in milliseconds that the caret is on and off. 0 = steady on.\r
set void SetCaretPeriod=2076(int periodMilliseconds,)\r
\r
# Set the set of characters making up words for when moving or selecting by word.\r
# First sets defaults like SetCharsDefault.\r
set void SetWordChars=2077(, string characters)\r
\r
# Get the set of characters making up words for when moving or selecting by word.\r
# Returns the number of characters\r
get int GetWordChars=2646(, stringresult characters)\r
\r
# Start a sequence of actions that is undone and redone as a unit.\r
# May be nested.\r
fun void BeginUndoAction=2078(,)\r
\r
# End a sequence of actions that is undone and redone as a unit.\r
fun void EndUndoAction=2079(,)\r
\r
# Indicator style enumeration and some constants\r
enu IndicatorStyle=INDIC_\r
val INDIC_PLAIN=0\r
val INDIC_SQUIGGLE=1\r
val INDIC_TT=2\r
val INDIC_DIAGONAL=3\r
val INDIC_STRIKE=4\r
val INDIC_HIDDEN=5\r
val INDIC_BOX=6\r
val INDIC_ROUNDBOX=7\r
val INDIC_STRAIGHTBOX=8\r
val INDIC_DASH=9\r
val INDIC_DOTS=10\r
val INDIC_SQUIGGLELOW=11\r
val INDIC_DOTBOX=12\r
val INDIC_SQUIGGLEPIXMAP=13\r
val INDIC_COMPOSITIONTHICK=14\r
val INDIC_COMPOSITIONTHIN=15\r
val INDIC_FULLBOX=16\r
val INDIC_TEXTFORE=17\r
val INDIC_IME=32\r
val INDIC_IME_MAX=35\r
val INDIC_MAX=35\r
val INDIC_CONTAINER=8\r
val INDIC0_MASK=0x20\r
val INDIC1_MASK=0x40\r
val INDIC2_MASK=0x80\r
val INDICS_MASK=0xE0\r
\r
# Set an indicator to plain, squiggle or TT.\r
set void IndicSetStyle=2080(int indic, int style)\r
\r
# Retrieve the style of an indicator.\r
get int IndicGetStyle=2081(int indic,)\r
\r
# Set the foreground colour of an indicator.\r
set void IndicSetFore=2082(int indic, colour fore)\r
\r
# Retrieve the foreground colour of an indicator.\r
get colour IndicGetFore=2083(int indic,)\r
\r
# Set an indicator to draw under text or over(default).\r
set void IndicSetUnder=2510(int indic, bool under)\r
\r
# Retrieve whether indicator drawn under or over text.\r
get bool IndicGetUnder=2511(int indic,)\r
\r
# Set a hover indicator to plain, squiggle or TT.\r
set void IndicSetHoverStyle=2680(int indic, int style)\r
\r
# Retrieve the hover style of an indicator.\r
get int IndicGetHoverStyle=2681(int indic,)\r
\r
# Set the foreground hover colour of an indicator.\r
set void IndicSetHoverFore=2682(int indic, colour fore)\r
\r
# Retrieve the foreground hover colour of an indicator.\r
get colour IndicGetHoverFore=2683(int indic,)\r
\r
val SC_INDICVALUEBIT=0x1000000\r
val SC_INDICVALUEMASK=0xFFFFFF\r
\r
enu IndicFlag=SC_INDICFLAG_\r
val SC_INDICFLAG_VALUEFORE=1\r
\r
# Set the attributes of an indicator.\r
set void IndicSetFlags=2684(int indic, int flags)\r
\r
# Retrieve the attributes of an indicator.\r
get int IndicGetFlags=2685(int indic,)\r
\r
# Set the foreground colour of all whitespace and whether to use this setting.\r
fun void SetWhitespaceFore=2084(bool useSetting, colour fore)\r
\r
# Set the background colour of all whitespace and whether to use this setting.\r
fun void SetWhitespaceBack=2085(bool useSetting, colour back)\r
\r
# Set the size of the dots used to mark space characters.\r
set void SetWhitespaceSize=2086(int size,)\r
\r
# Get the size of the dots used to mark space characters.\r
get int GetWhitespaceSize=2087(,)\r
\r
# Divide each styling byte into lexical class bits (default: 5) and indicator\r
# bits (default: 3). If a lexer requires more than 32 lexical states, then this\r
# is used to expand the possible states.\r
set void SetStyleBits=2090(int bits,)\r
\r
# Retrieve number of bits in style bytes used to hold the lexical state.\r
get int GetStyleBits=2091(,)\r
\r
# Used to hold extra styling information for each line.\r
set void SetLineState=2092(int line, int state)\r
\r
# Retrieve the extra styling information for a line.\r
get int GetLineState=2093(int line,)\r
\r
# Retrieve the last line number that has line state.\r
get int GetMaxLineState=2094(,)\r
\r
# Is the background of the line containing the caret in a different colour?\r
get bool GetCaretLineVisible=2095(,)\r
\r
# Display the background of the line containing the caret in a different colour.\r
set void SetCaretLineVisible=2096(bool show,)\r
\r
# Get the colour of the background of the line containing the caret.\r
get colour GetCaretLineBack=2097(,)\r
\r
# Set the colour of the background of the line containing the caret.\r
set void SetCaretLineBack=2098(colour back,)\r
\r
# Set a style to be changeable or not (read only).\r
# Experimental feature, currently buggy.\r
set void StyleSetChangeable=2099(int style, bool changeable)\r
\r
# Display a auto-completion list.\r
# The lenEntered parameter indicates how many characters before\r
# the caret should be used to provide context.\r
fun void AutoCShow=2100(int lenEntered, string itemList)\r
\r
# Remove the auto-completion list from the screen.\r
fun void AutoCCancel=2101(,)\r
\r
# Is there an auto-completion list visible?\r
fun bool AutoCActive=2102(,)\r
\r
# Retrieve the position of the caret when the auto-completion list was displayed.\r
fun position AutoCPosStart=2103(,)\r
\r
# User has selected an item so remove the list and insert the selection.\r
fun void AutoCComplete=2104(,)\r
\r
# Define a set of character that when typed cancel the auto-completion list.\r
fun void AutoCStops=2105(, string characterSet)\r
\r
# Change the separator character in the string setting up an auto-completion list.\r
# Default is space but can be changed if items contain space.\r
set void AutoCSetSeparator=2106(int separatorCharacter,)\r
\r
# Retrieve the auto-completion list separator character.\r
get int AutoCGetSeparator=2107(,)\r
\r
# Select the item in the auto-completion list that starts with a string.\r
fun void AutoCSelect=2108(, string text)\r
\r
# Should the auto-completion list be cancelled if the user backspaces to a\r
# position before where the box was created.\r
set void AutoCSetCancelAtStart=2110(bool cancel,)\r
\r
# Retrieve whether auto-completion cancelled by backspacing before start.\r
get bool AutoCGetCancelAtStart=2111(,)\r
\r
# Define a set of characters that when typed will cause the autocompletion to\r
# choose the selected item.\r
set void AutoCSetFillUps=2112(, string characterSet)\r
\r
# Should a single item auto-completion list automatically choose the item.\r
set void AutoCSetChooseSingle=2113(bool chooseSingle,)\r
\r
# Retrieve whether a single item auto-completion list automatically choose the item.\r
get bool AutoCGetChooseSingle=2114(,)\r
\r
# Set whether case is significant when performing auto-completion searches.\r
set void AutoCSetIgnoreCase=2115(bool ignoreCase,)\r
\r
# Retrieve state of ignore case flag.\r
get bool AutoCGetIgnoreCase=2116(,)\r
\r
# Display a list of strings and send notification when user chooses one.\r
fun void UserListShow=2117(int listType, string itemList)\r
\r
# Set whether or not autocompletion is hidden automatically when nothing matches.\r
set void AutoCSetAutoHide=2118(bool autoHide,)\r
\r
# Retrieve whether or not autocompletion is hidden automatically when nothing matches.\r
get bool AutoCGetAutoHide=2119(,)\r
\r
# Set whether or not autocompletion deletes any word characters\r
# after the inserted text upon completion.\r
set void AutoCSetDropRestOfWord=2270(bool dropRestOfWord,)\r
\r
# Retrieve whether or not autocompletion deletes any word characters\r
# after the inserted text upon completion.\r
get bool AutoCGetDropRestOfWord=2271(,)\r
\r
# Register an XPM image for use in autocompletion lists.\r
fun void RegisterImage=2405(int type, string xpmData)\r
\r
# Clear all the registered XPM images.\r
fun void ClearRegisteredImages=2408(,)\r
\r
# Retrieve the auto-completion list type-separator character.\r
get int AutoCGetTypeSeparator=2285(,)\r
\r
# Change the type-separator character in the string setting up an auto-completion list.\r
# Default is '?' but can be changed if items contain '?'.\r
set void AutoCSetTypeSeparator=2286(int separatorCharacter,)\r
\r
# Set the maximum width, in characters, of auto-completion and user lists.\r
# Set to 0 to autosize to fit longest item, which is the default.\r
set void AutoCSetMaxWidth=2208(int characterCount,)\r
\r
# Get the maximum width, in characters, of auto-completion and user lists.\r
get int AutoCGetMaxWidth=2209(,)\r
\r
# Set the maximum height, in rows, of auto-completion and user lists.\r
# The default is 5 rows.\r
set void AutoCSetMaxHeight=2210(int rowCount,)\r
\r
# Set the maximum height, in rows, of auto-completion and user lists.\r
get int AutoCGetMaxHeight=2211(,)\r
\r
# Set the number of spaces used for one level of indentation.\r
set void SetIndent=2122(int indentSize,)\r
\r
# Retrieve indentation size.\r
get int GetIndent=2123(,)\r
\r
# Indentation will only use space characters if useTabs is false, otherwise\r
# it will use a combination of tabs and spaces.\r
set void SetUseTabs=2124(bool useTabs,)\r
\r
# Retrieve whether tabs will be used in indentation.\r
get bool GetUseTabs=2125(,)\r
\r
# Change the indentation of a line to a number of columns.\r
set void SetLineIndentation=2126(int line, int indentSize)\r
\r
# Retrieve the number of columns that a line is indented.\r
get int GetLineIndentation=2127(int line,)\r
\r
# Retrieve the position before the first non indentation character on a line.\r
get position GetLineIndentPosition=2128(int line,)\r
\r
# Retrieve the column number of a position, taking tab width into account.\r
get int GetColumn=2129(position pos,)\r
\r
# Count characters between two positions.\r
fun int CountCharacters=2633(int startPos, int endPos)\r
\r
# Show or hide the horizontal scroll bar.\r
set void SetHScrollBar=2130(bool show,)\r
# Is the horizontal scroll bar visible?\r
get bool GetHScrollBar=2131(,)\r
\r
enu IndentView=SC_IV_\r
val SC_IV_NONE=0\r
val SC_IV_REAL=1\r
val SC_IV_LOOKFORWARD=2\r
val SC_IV_LOOKBOTH=3\r
\r
# Show or hide indentation guides.\r
set void SetIndentationGuides=2132(int indentView,)\r
\r
# Are the indentation guides visible?\r
get int GetIndentationGuides=2133(,)\r
\r
# Set the highlighted indentation guide column.\r
# 0 = no highlighted guide.\r
set void SetHighlightGuide=2134(int column,)\r
\r
# Get the highlighted indentation guide column.\r
get int GetHighlightGuide=2135(,)\r
\r
# Get the position after the last visible characters on a line.\r
get position GetLineEndPosition=2136(int line,)\r
\r
# Get the code page used to interpret the bytes of the document as characters.\r
get int GetCodePage=2137(,)\r
\r
# Get the foreground colour of the caret.\r
get colour GetCaretFore=2138(,)\r
\r
# In read-only mode?\r
get bool GetReadOnly=2140(,)\r
\r
# Sets the position of the caret.\r
set void SetCurrentPos=2141(position pos,)\r
\r
# Sets the position that starts the selection - this becomes the anchor.\r
set void SetSelectionStart=2142(position pos,)\r
\r
# Returns the position at the start of the selection.\r
get position GetSelectionStart=2143(,)\r
\r
# Sets the position that ends the selection - this becomes the currentPosition.\r
set void SetSelectionEnd=2144(position pos,)\r
\r
# Returns the position at the end of the selection.\r
get position GetSelectionEnd=2145(,)\r
\r
# Set caret to a position, while removing any existing selection.\r
fun void SetEmptySelection=2556(position pos,)\r
\r
# Sets the print magnification added to the point size of each style for printing.\r
set void SetPrintMagnification=2146(int magnification,)\r
\r
# Returns the print magnification.\r
get int GetPrintMagnification=2147(,)\r
\r
enu PrintOption=SC_PRINT_\r
# PrintColourMode - use same colours as screen.\r
val SC_PRINT_NORMAL=0\r
# PrintColourMode - invert the light value of each style for printing.\r
val SC_PRINT_INVERTLIGHT=1\r
# PrintColourMode - force black text on white background for printing.\r
val SC_PRINT_BLACKONWHITE=2\r
# PrintColourMode - text stays coloured, but all background is forced to be white for printing.\r
val SC_PRINT_COLOURONWHITE=3\r
# PrintColourMode - only the default-background is forced to be white for printing.\r
val SC_PRINT_COLOURONWHITEDEFAULTBG=4\r
\r
# Modify colours when printing for clearer printed text.\r
set void SetPrintColourMode=2148(int mode,)\r
\r
# Returns the print colour mode.\r
get int GetPrintColourMode=2149(,)\r
\r
enu FindOption=SCFIND_\r
val SCFIND_WHOLEWORD=0x2\r
val SCFIND_MATCHCASE=0x4\r
val SCFIND_WORDSTART=0x00100000\r
val SCFIND_REGEXP=0x00200000\r
val SCFIND_POSIX=0x00400000\r
val SCFIND_CXX11REGEX=0x00800000\r
\r
# Find some text in the document.\r
fun position FindText=2150(int flags, findtext ft)\r
\r
# On Windows, will draw the document into a display context such as a printer.\r
fun position FormatRange=2151(bool draw, formatrange fr)\r
\r
# Retrieve the display line at the top of the display.\r
get int GetFirstVisibleLine=2152(,)\r
\r
# Retrieve the contents of a line.\r
# Returns the length of the line.\r
fun int GetLine=2153(int line, stringresult text)\r
\r
# Returns the number of lines in the document. There is always at least one.\r
get int GetLineCount=2154(,)\r
\r
# Sets the size in pixels of the left margin.\r
set void SetMarginLeft=2155(, int pixelWidth)\r
\r
# Returns the size in pixels of the left margin.\r
get int GetMarginLeft=2156(,)\r
\r
# Sets the size in pixels of the right margin.\r
set void SetMarginRight=2157(, int pixelWidth)\r
\r
# Returns the size in pixels of the right margin.\r
get int GetMarginRight=2158(,)\r
\r
# Is the document different from when it was last saved?\r
get bool GetModify=2159(,)\r
\r
# Select a range of text.\r
fun void SetSel=2160(position start, position end)\r
\r
# Retrieve the selected text.\r
# Return the length of the text.\r
# Result is NUL-terminated.\r
fun int GetSelText=2161(, stringresult text)\r
\r
# Retrieve a range of text.\r
# Return the length of the text.\r
fun int GetTextRange=2162(, textrange tr)\r
\r
# Draw the selection in normal style or with selection highlighted.\r
fun void HideSelection=2163(bool normal,)\r
\r
# Retrieve the x value of the point in the window where a position is displayed.\r
fun int PointXFromPosition=2164(, position pos)\r
\r
# Retrieve the y value of the point in the window where a position is displayed.\r
fun int PointYFromPosition=2165(, position pos)\r
\r
# Retrieve the line containing a position.\r
fun int LineFromPosition=2166(position pos,)\r
\r
# Retrieve the position at the start of a line.\r
fun position PositionFromLine=2167(int line,)\r
\r
# Scroll horizontally and vertically.\r
fun void LineScroll=2168(int columns, int lines)\r
\r
# Ensure the caret is visible.\r
fun void ScrollCaret=2169(,)\r
\r
# Scroll the argument positions and the range between them into view giving\r
# priority to the primary position then the secondary position.\r
# This may be used to make a search match visible.\r
fun void ScrollRange=2569(position secondary, position primary)\r
\r
# Replace the selected text with the argument text.\r
fun void ReplaceSel=2170(, string text)\r
\r
# Set to read only or read write.\r
set void SetReadOnly=2171(bool readOnly,)\r
\r
# Null operation.\r
fun void Null=2172(,)\r
\r
# Will a paste succeed?\r
fun bool CanPaste=2173(,)\r
\r
# Are there any undoable actions in the undo history?\r
fun bool CanUndo=2174(,)\r
\r
# Delete the undo history.\r
fun void EmptyUndoBuffer=2175(,)\r
\r
# Undo one action in the undo history.\r
fun void Undo=2176(,)\r
\r
# Cut the selection to the clipboard.\r
fun void Cut=2177(,)\r
\r
# Copy the selection to the clipboard.\r
fun void Copy=2178(,)\r
\r
# Paste the contents of the clipboard into the document replacing the selection.\r
fun void Paste=2179(,)\r
\r
# Clear the selection.\r
fun void Clear=2180(,)\r
\r
# Replace the contents of the document with the argument text.\r
fun void SetText=2181(, string text)\r
\r
# Retrieve all the text in the document.\r
# Returns number of characters retrieved.\r
# Result is NUL-terminated.\r
fun int GetText=2182(int length, stringresult text)\r
\r
# Retrieve the number of characters in the document.\r
get int GetTextLength=2183(,)\r
\r
# Retrieve a pointer to a function that processes messages for this Scintilla.\r
get int GetDirectFunction=2184(,)\r
\r
# Retrieve a pointer value to use as the first argument when calling\r
# the function returned by GetDirectFunction.\r
get int GetDirectPointer=2185(,)\r
\r
# Set to overtype (true) or insert mode.\r
set void SetOvertype=2186(bool overtype,)\r
\r
# Returns true if overtype mode is active otherwise false is returned.\r
get bool GetOvertype=2187(,)\r
\r
# Set the width of the insert mode caret.\r
set void SetCaretWidth=2188(int pixelWidth,)\r
\r
# Returns the width of the insert mode caret.\r
get int GetCaretWidth=2189(,)\r
\r
# Sets the position that starts the target which is used for updating the\r
# document without affecting the scroll position.\r
set void SetTargetStart=2190(position pos,)\r
\r
# Get the position that starts the target.\r
get position GetTargetStart=2191(,)\r
\r
# Sets the position that ends the target which is used for updating the\r
# document without affecting the scroll position.\r
set void SetTargetEnd=2192(position pos,)\r
\r
# Get the position that ends the target.\r
get position GetTargetEnd=2193(,)\r
\r
# Sets both the start and end of the target in one call.\r
fun void SetTargetRange=2686(position start, position end)\r
\r
# Retrieve the text in the target.\r
get int GetTargetText=2687(, stringresult characters)\r
\r
# Make the target range start and end be the same as the selection range start and end.\r
fun void TargetFromSelection=2287(,)\r
\r
# Sets the target to the whole document.\r
fun void TargetWholeDocument=2690(,)\r
\r
# Replace the target text with the argument text.\r
# Text is counted so it can contain NULs.\r
# Returns the length of the replacement text.\r
fun int ReplaceTarget=2194(int length, string text)\r
\r
# Replace the target text with the argument text after \d processing.\r
# Text is counted so it can contain NULs.\r
# Looks for \d where d is between 1 and 9 and replaces these with the strings\r
# matched in the last search operation which were surrounded by \( and \).\r
# Returns the length of the replacement text including any change\r
# caused by processing the \d patterns.\r
fun int ReplaceTargetRE=2195(int length, string text)\r
\r
# Search for a counted string in the target and set the target to the found\r
# range. Text is counted so it can contain NULs.\r
# Returns length of range or -1 for failure in which case target is not moved.\r
fun int SearchInTarget=2197(int length, string text)\r
\r
# Set the search flags used by SearchInTarget.\r
set void SetSearchFlags=2198(int flags,)\r
\r
# Get the search flags used by SearchInTarget.\r
get int GetSearchFlags=2199(,)\r
\r
# Show a call tip containing a definition near position pos.\r
fun void CallTipShow=2200(position pos, string definition)\r
\r
# Remove the call tip from the screen.\r
fun void CallTipCancel=2201(,)\r
\r
# Is there an active call tip?\r
fun bool CallTipActive=2202(,)\r
\r
# Retrieve the position where the caret was before displaying the call tip.\r
fun position CallTipPosStart=2203(,)\r
\r
# Set the start position in order to change when backspacing removes the calltip.\r
set void CallTipSetPosStart=2214(int posStart,)\r
\r
# Highlight a segment of the definition.\r
fun void CallTipSetHlt=2204(int start, int end)\r
\r
# Set the background colour for the call tip.\r
set void CallTipSetBack=2205(colour back,)\r
\r
# Set the foreground colour for the call tip.\r
set void CallTipSetFore=2206(colour fore,)\r
\r
# Set the foreground colour for the highlighted part of the call tip.\r
set void CallTipSetForeHlt=2207(colour fore,)\r
\r
# Enable use of STYLE_CALLTIP and set call tip tab size in pixels.\r
set void CallTipUseStyle=2212(int tabSize,)\r
\r
# Set position of calltip, above or below text.\r
set void CallTipSetPosition=2213(bool above,)\r
\r
# Find the display line of a document line taking hidden lines into account.\r
fun int VisibleFromDocLine=2220(int line,)\r
\r
# Find the document line of a display line taking hidden lines into account.\r
fun int DocLineFromVisible=2221(int lineDisplay,)\r
\r
# The number of display lines needed to wrap a document line\r
fun int WrapCount=2235(int line,)\r
\r
enu FoldLevel=SC_FOLDLEVEL\r
val SC_FOLDLEVELBASE=0x400\r
val SC_FOLDLEVELWHITEFLAG=0x1000\r
val SC_FOLDLEVELHEADERFLAG=0x2000\r
val SC_FOLDLEVELNUMBERMASK=0x0FFF\r
\r
# Set the fold level of a line.\r
# This encodes an integer level along with flags indicating whether the\r
# line is a header and whether it is effectively white space.\r
set void SetFoldLevel=2222(int line, int level)\r
\r
# Retrieve the fold level of a line.\r
get int GetFoldLevel=2223(int line,)\r
\r
# Find the last child line of a header line.\r
get int GetLastChild=2224(int line, int level)\r
\r
# Find the parent line of a child line.\r
get int GetFoldParent=2225(int line,)\r
\r
# Make a range of lines visible.\r
fun void ShowLines=2226(int lineStart, int lineEnd)\r
\r
# Make a range of lines invisible.\r
fun void HideLines=2227(int lineStart, int lineEnd)\r
\r
# Is a line visible?\r
get bool GetLineVisible=2228(int line,)\r
\r
# Are all lines visible?\r
get bool GetAllLinesVisible=2236(,)\r
\r
# Show the children of a header line.\r
set void SetFoldExpanded=2229(int line, bool expanded)\r
\r
# Is a header line expanded?\r
get bool GetFoldExpanded=2230(int line,)\r
\r
# Switch a header line between expanded and contracted.\r
fun void ToggleFold=2231(int line,)\r
\r
enu FoldAction=SC_FOLDACTION\r
val SC_FOLDACTION_CONTRACT=0\r
val SC_FOLDACTION_EXPAND=1\r
val SC_FOLDACTION_TOGGLE=2\r
\r
# Expand or contract a fold header.\r
fun void FoldLine=2237(int line, int action)\r
\r
# Expand or contract a fold header and its children.\r
fun void FoldChildren=2238(int line, int action)\r
\r
# Expand a fold header and all children. Use the level argument instead of the line's current level.\r
fun void ExpandChildren=2239(int line, int level)\r
\r
# Expand or contract all fold headers.\r
fun void FoldAll=2662(int action,)\r
\r
# Ensure a particular line is visible by expanding any header line hiding it.\r
fun void EnsureVisible=2232(int line,)\r
\r
enu AutomaticFold=SC_AUTOMATICFOLD_\r
val SC_AUTOMATICFOLD_SHOW=0x0001\r
val SC_AUTOMATICFOLD_CLICK=0x0002\r
val SC_AUTOMATICFOLD_CHANGE=0x0004\r
\r
# Set automatic folding behaviours.\r
set void SetAutomaticFold=2663(int automaticFold,)\r
\r
# Get automatic folding behaviours.\r
get int GetAutomaticFold=2664(,)\r
\r
enu FoldFlag=SC_FOLDFLAG_\r
val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002\r
val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004\r
val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008\r
val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010\r
val SC_FOLDFLAG_LEVELNUMBERS=0x0040\r
val SC_FOLDFLAG_LINESTATE=0x0080\r
\r
# Set some style options for folding.\r
set void SetFoldFlags=2233(int flags,)\r
\r
# Ensure a particular line is visible by expanding any header line hiding it.\r
# Use the currently set visibility policy to determine which range to display.\r
fun void EnsureVisibleEnforcePolicy=2234(int line,)\r
\r
# Sets whether a tab pressed when caret is within indentation indents.\r
set void SetTabIndents=2260(bool tabIndents,)\r
\r
# Does a tab pressed when caret is within indentation indent?\r
get bool GetTabIndents=2261(,)\r
\r
# Sets whether a backspace pressed when caret is within indentation unindents.\r
set void SetBackSpaceUnIndents=2262(bool bsUnIndents,)\r
\r
# Does a backspace pressed when caret is within indentation unindent?\r
get bool GetBackSpaceUnIndents=2263(,)\r
\r
val SC_TIME_FOREVER=10000000\r
\r
# Sets the time the mouse must sit still to generate a mouse dwell event.\r
set void SetMouseDwellTime=2264(int periodMilliseconds,)\r
\r
# Retrieve the time the mouse must sit still to generate a mouse dwell event.\r
get int GetMouseDwellTime=2265(,)\r
\r
# Get position of start of word.\r
fun int WordStartPosition=2266(position pos, bool onlyWordCharacters)\r
\r
# Get position of end of word.\r
fun int WordEndPosition=2267(position pos, bool onlyWordCharacters)\r
\r
# Is the range start..end considered a word?\r
fun bool IsRangeWord=2691(position start, position end)\r
\r
enu Wrap=SC_WRAP_\r
val SC_WRAP_NONE=0\r
val SC_WRAP_WORD=1\r
val SC_WRAP_CHAR=2\r
val SC_WRAP_WHITESPACE=3\r
\r
# Sets whether text is word wrapped.\r
set void SetWrapMode=2268(int mode,)\r
\r
# Retrieve whether text is word wrapped.\r
get int GetWrapMode=2269(,)\r
\r
enu WrapVisualFlag=SC_WRAPVISUALFLAG_\r
val SC_WRAPVISUALFLAG_NONE=0x0000\r
val SC_WRAPVISUALFLAG_END=0x0001\r
val SC_WRAPVISUALFLAG_START=0x0002\r
val SC_WRAPVISUALFLAG_MARGIN=0x0004\r
\r
# Set the display mode of visual flags for wrapped lines.\r
set void SetWrapVisualFlags=2460(int wrapVisualFlags,)\r
\r
# Retrive the display mode of visual flags for wrapped lines.\r
get int GetWrapVisualFlags=2461(,)\r
\r
enu WrapVisualLocation=SC_WRAPVISUALFLAGLOC_\r
val SC_WRAPVISUALFLAGLOC_DEFAULT=0x0000\r
val SC_WRAPVISUALFLAGLOC_END_BY_TEXT=0x0001\r
val SC_WRAPVISUALFLAGLOC_START_BY_TEXT=0x0002\r
\r
# Set the location of visual flags for wrapped lines.\r
set void SetWrapVisualFlagsLocation=2462(int wrapVisualFlagsLocation,)\r
\r
# Retrive the location of visual flags for wrapped lines.\r
get int GetWrapVisualFlagsLocation=2463(,)\r
\r
# Set the start indent for wrapped lines.\r
set void SetWrapStartIndent=2464(int indent,)\r
\r
# Retrive the start indent for wrapped lines.\r
get int GetWrapStartIndent=2465(,)\r
\r
enu WrapIndentMode=SC_WRAPINDENT_\r
val SC_WRAPINDENT_FIXED=0\r
val SC_WRAPINDENT_SAME=1\r
val SC_WRAPINDENT_INDENT=2\r
\r
# Sets how wrapped sublines are placed. Default is fixed.\r
set void SetWrapIndentMode=2472(int mode,)\r
\r
# Retrieve how wrapped sublines are placed. Default is fixed.\r
get int GetWrapIndentMode=2473(,)\r
\r
enu LineCache=SC_CACHE_\r
val SC_CACHE_NONE=0\r
val SC_CACHE_CARET=1\r
val SC_CACHE_PAGE=2\r
val SC_CACHE_DOCUMENT=3\r
\r
# Sets the degree of caching of layout information.\r
set void SetLayoutCache=2272(int mode,)\r
\r
# Retrieve the degree of caching of layout information.\r
get int GetLayoutCache=2273(,)\r
\r
# Sets the document width assumed for scrolling.\r
set void SetScrollWidth=2274(int pixelWidth,)\r
\r
# Retrieve the document width assumed for scrolling.\r
get int GetScrollWidth=2275(,)\r
\r
# Sets whether the maximum width line displayed is used to set scroll width.\r
set void SetScrollWidthTracking=2516(bool tracking,)\r
\r
# Retrieve whether the scroll width tracks wide lines.\r
get bool GetScrollWidthTracking=2517(,)\r
\r
# Measure the pixel width of some text in a particular style.\r
# NUL terminated text argument.\r
# Does not handle tab or control characters.\r
fun int TextWidth=2276(int style, string text)\r
\r
# Sets the scroll range so that maximum scroll position has\r
# the last line at the bottom of the view (default).\r
# Setting this to false allows scrolling one page below the last line.\r
set void SetEndAtLastLine=2277(bool endAtLastLine,)\r
\r
# Retrieve whether the maximum scroll position has the last\r
# line at the bottom of the view.\r
get bool GetEndAtLastLine=2278(,)\r
\r
# Retrieve the height of a particular line of text in pixels.\r
fun int TextHeight=2279(int line,)\r
\r
# Show or hide the vertical scroll bar.\r
set void SetVScrollBar=2280(bool show,)\r
\r
# Is the vertical scroll bar visible?\r
get bool GetVScrollBar=2281(,)\r
\r
# Append a string to the end of the document without changing the selection.\r
fun void AppendText=2282(int length, string text)\r
\r
# Is drawing done in two phases with backgrounds drawn before foregrounds?\r
get bool GetTwoPhaseDraw=2283(,)\r
\r
# In twoPhaseDraw mode, drawing is performed in two phases, first the background\r
# and then the foreground. This avoids chopping off characters that overlap the next run.\r
set void SetTwoPhaseDraw=2284(bool twoPhase,)\r
\r
enu FontQuality=SC_PHASES_\r
val SC_PHASES_ONE=0\r
val SC_PHASES_TWO=1\r
val SC_PHASES_MULTIPLE=2\r
\r
# How many phases is drawing done in?\r
get int GetPhasesDraw=2673(,)\r
\r
# In one phase draw, text is drawn in a series of rectangular blocks with no overlap.\r
# In two phase draw, text is drawn in a series of lines allowing runs to overlap horizontally.\r
# In multiple phase draw, each element is drawn over the whole drawing area, allowing text\r
# to overlap from one line to the next.\r
set void SetPhasesDraw=2674(int phases,)\r
\r
# Control font anti-aliasing.\r
\r
enu FontQuality=SC_EFF_\r
val SC_EFF_QUALITY_MASK=0xF\r
val SC_EFF_QUALITY_DEFAULT=0\r
val SC_EFF_QUALITY_NON_ANTIALIASED=1\r
val SC_EFF_QUALITY_ANTIALIASED=2\r
val SC_EFF_QUALITY_LCD_OPTIMIZED=3\r
\r
# Choose the quality level for text from the FontQuality enumeration.\r
set void SetFontQuality=2611(int fontQuality,)\r
\r
# Retrieve the quality level for text.\r
get int GetFontQuality=2612(,)\r
\r
# Scroll so that a display line is at the top of the display.\r
set void SetFirstVisibleLine=2613(int lineDisplay,)\r
\r
enu MultiPaste=SC_MULTIPASTE_\r
val SC_MULTIPASTE_ONCE=0\r
val SC_MULTIPASTE_EACH=1\r
\r
# Change the effect of pasting when there are multiple selections.\r
set void SetMultiPaste=2614(int multiPaste,)\r
\r
# Retrieve the effect of pasting when there are multiple selections..\r
get int GetMultiPaste=2615(,)\r
\r
# Retrieve the value of a tag from a regular expression search.\r
# Result is NUL-terminated.\r
get int GetTag=2616(int tagNumber, stringresult tagValue)\r
\r
# Join the lines in the target.\r
fun void LinesJoin=2288(,)\r
\r
# Split the lines in the target into lines that are less wide than pixelWidth\r
# where possible.\r
fun void LinesSplit=2289(int pixelWidth,)\r
\r
# Set the colours used as a chequerboard pattern in the fold margin\r
fun void SetFoldMarginColour=2290(bool useSetting, colour back)\r
fun void SetFoldMarginHiColour=2291(bool useSetting, colour fore)\r
\r
## New messages go here\r
\r
## Start of key messages\r
# Move caret down one line.\r
fun void LineDown=2300(,)\r
\r
# Move caret down one line extending selection to new caret position.\r
fun void LineDownExtend=2301(,)\r
\r
# Move caret up one line.\r
fun void LineUp=2302(,)\r
\r
# Move caret up one line extending selection to new caret position.\r
fun void LineUpExtend=2303(,)\r
\r
# Move caret left one character.\r
fun void CharLeft=2304(,)\r
\r
# Move caret left one character extending selection to new caret position.\r
fun void CharLeftExtend=2305(,)\r
\r
# Move caret right one character.\r
fun void CharRight=2306(,)\r
\r
# Move caret right one character extending selection to new caret position.\r
fun void CharRightExtend=2307(,)\r
\r
# Move caret left one word.\r
fun void WordLeft=2308(,)\r
\r
# Move caret left one word extending selection to new caret position.\r
fun void WordLeftExtend=2309(,)\r
\r
# Move caret right one word.\r
fun void WordRight=2310(,)\r
\r
# Move caret right one word extending selection to new caret position.\r
fun void WordRightExtend=2311(,)\r
\r
# Move caret to first position on line.\r
fun void Home=2312(,)\r
\r
# Move caret to first position on line extending selection to new caret position.\r
fun void HomeExtend=2313(,)\r
\r
# Move caret to last position on line.\r
fun void LineEnd=2314(,)\r
\r
# Move caret to last position on line extending selection to new caret position.\r
fun void LineEndExtend=2315(,)\r
\r
# Move caret to first position in document.\r
fun void DocumentStart=2316(,)\r
\r
# Move caret to first position in document extending selection to new caret position.\r
fun void DocumentStartExtend=2317(,)\r
\r
# Move caret to last position in document.\r
fun void DocumentEnd=2318(,)\r
\r
# Move caret to last position in document extending selection to new caret position.\r
fun void DocumentEndExtend=2319(,)\r
\r
# Move caret one page up.\r
fun void PageUp=2320(,)\r
\r
# Move caret one page up extending selection to new caret position.\r
fun void PageUpExtend=2321(,)\r
\r
# Move caret one page down.\r
fun void PageDown=2322(,)\r
\r
# Move caret one page down extending selection to new caret position.\r
fun void PageDownExtend=2323(,)\r
\r
# Switch from insert to overtype mode or the reverse.\r
fun void EditToggleOvertype=2324(,)\r
\r
# Cancel any modes such as call tip or auto-completion list display.\r
fun void Cancel=2325(,)\r
\r
# Delete the selection or if no selection, the character before the caret.\r
fun void DeleteBack=2326(,)\r
\r
# If selection is empty or all on one line replace the selection with a tab character.\r
# If more than one line selected, indent the lines.\r
fun void Tab=2327(,)\r
\r
# Dedent the selected lines.\r
fun void BackTab=2328(,)\r
\r
# Insert a new line, may use a CRLF, CR or LF depending on EOL mode.\r
fun void NewLine=2329(,)\r
\r
# Insert a Form Feed character.\r
fun void FormFeed=2330(,)\r
\r
# Move caret to before first visible character on line.\r
# If already there move to first character on line.\r
fun void VCHome=2331(,)\r
\r
# Like VCHome but extending selection to new caret position.\r
fun void VCHomeExtend=2332(,)\r
\r
# Magnify the displayed text by increasing the sizes by 1 point.\r
fun void ZoomIn=2333(,)\r
\r
# Make the displayed text smaller by decreasing the sizes by 1 point.\r
fun void ZoomOut=2334(,)\r
\r
# Delete the word to the left of the caret.\r
fun void DelWordLeft=2335(,)\r
\r
# Delete the word to the right of the caret.\r
fun void DelWordRight=2336(,)\r
\r
# Delete the word to the right of the caret, but not the trailing non-word characters.\r
fun void DelWordRightEnd=2518(,)\r
\r
# Cut the line containing the caret.\r
fun void LineCut=2337(,)\r
\r
# Delete the line containing the caret.\r
fun void LineDelete=2338(,)\r
\r
# Switch the current line with the previous.\r
fun void LineTranspose=2339(,)\r
\r
# Duplicate the current line.\r
fun void LineDuplicate=2404(,)\r
\r
# Transform the selection to lower case.\r
fun void LowerCase=2340(,)\r
\r
# Transform the selection to upper case.\r
fun void UpperCase=2341(,)\r
\r
# Scroll the document down, keeping the caret visible.\r
fun void LineScrollDown=2342(,)\r
\r
# Scroll the document up, keeping the caret visible.\r
fun void LineScrollUp=2343(,)\r
\r
# Delete the selection or if no selection, the character before the caret.\r
# Will not delete the character before at the start of a line.\r
fun void DeleteBackNotLine=2344(,)\r
\r
# Move caret to first position on display line.\r
fun void HomeDisplay=2345(,)\r
\r
# Move caret to first position on display line extending selection to\r
# new caret position.\r
fun void HomeDisplayExtend=2346(,)\r
\r
# Move caret to last position on display line.\r
fun void LineEndDisplay=2347(,)\r
\r
# Move caret to last position on display line extending selection to new\r
# caret position.\r
fun void LineEndDisplayExtend=2348(,)\r
\r
# These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?\r
# except they behave differently when word-wrap is enabled:\r
# They go first to the start / end of the display line, like (Home|LineEnd)Display\r
# The difference is that, the cursor is already at the point, it goes on to the start\r
# or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.\r
\r
fun void HomeWrap=2349(,)\r
fun void HomeWrapExtend=2450(,)\r
fun void LineEndWrap=2451(,)\r
fun void LineEndWrapExtend=2452(,)\r
fun void VCHomeWrap=2453(,)\r
fun void VCHomeWrapExtend=2454(,)\r
\r
# Copy the line containing the caret.\r
fun void LineCopy=2455(,)\r
\r
# Move the caret inside current view if it's not there already.\r
fun void MoveCaretInsideView=2401(,)\r
\r
# How many characters are on a line, including end of line characters?\r
fun int LineLength=2350(int line,)\r
\r
# Highlight the characters at two positions.\r
fun void BraceHighlight=2351(position pos1, position pos2)\r
\r
# Use specified indicator to highlight matching braces instead of changing their style.\r
fun void BraceHighlightIndicator=2498(bool useBraceHighlightIndicator, int indicator)\r
\r
# Highlight the character at a position indicating there is no matching brace.\r
fun void BraceBadLight=2352(position pos,)\r
\r
# Use specified indicator to highlight non matching brace instead of changing its style.\r
fun void BraceBadLightIndicator=2499(bool useBraceBadLightIndicator, int indicator)\r
\r
# Find the position of a matching brace or INVALID_POSITION if no match.\r
fun position BraceMatch=2353(position pos,)\r
\r
# Are the end of line characters visible?\r
get bool GetViewEOL=2355(,)\r
\r
# Make the end of line characters visible or invisible.\r
set void SetViewEOL=2356(bool visible,)\r
\r
# Retrieve a pointer to the document object.\r
get int GetDocPointer=2357(,)\r
\r
# Change the document object used.\r
set void SetDocPointer=2358(, int pointer)\r
\r
# Set which document modification events are sent to the container.\r
set void SetModEventMask=2359(int mask,)\r
\r
enu EdgeVisualStyle=EDGE_\r
val EDGE_NONE=0\r
val EDGE_LINE=1\r
val EDGE_BACKGROUND=2\r
\r
# Retrieve the column number which text should be kept within.\r
get int GetEdgeColumn=2360(,)\r
\r
# Set the column number of the edge.\r
# If text goes past the edge then it is highlighted.\r
set void SetEdgeColumn=2361(int column,)\r
\r
# Retrieve the edge highlight mode.\r
get int GetEdgeMode=2362(,)\r
\r
# The edge may be displayed by a line (EDGE_LINE) or by highlighting text that\r
# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).\r
set void SetEdgeMode=2363(int mode,)\r
\r
# Retrieve the colour used in edge indication.\r
get colour GetEdgeColour=2364(,)\r
\r
# Change the colour used in edge indication.\r
set void SetEdgeColour=2365(colour edgeColour,)\r
\r
# Sets the current caret position to be the search anchor.\r
fun void SearchAnchor=2366(,)\r
\r
# Find some text starting at the search anchor.\r
# Does not ensure the selection is visible.\r
fun int SearchNext=2367(int flags, string text)\r
\r
# Find some text starting at the search anchor and moving backwards.\r
# Does not ensure the selection is visible.\r
fun int SearchPrev=2368(int flags, string text)\r
\r
# Retrieves the number of lines completely visible.\r
get int LinesOnScreen=2370(,)\r
\r
# Set whether a pop up menu is displayed automatically when the user presses\r
# the wrong mouse button.\r
fun void UsePopUp=2371(bool allowPopUp,)\r
\r
# Is the selection rectangular? The alternative is the more common stream selection.\r
get bool SelectionIsRectangle=2372(,)\r
\r
# Set the zoom level. This number of points is added to the size of all fonts.\r
# It may be positive to magnify or negative to reduce.\r
set void SetZoom=2373(int zoom,)\r
# Retrieve the zoom level.\r
get int GetZoom=2374(,)\r
\r
# Create a new document object.\r
# Starts with reference count of 1 and not selected into editor.\r
fun int CreateDocument=2375(,)\r
# Extend life of document.\r
fun void AddRefDocument=2376(, int doc)\r
# Release a reference to the document, deleting document if it fades to black.\r
fun void ReleaseDocument=2377(, int doc)\r
\r
# Get which document modification events are sent to the container.\r
get int GetModEventMask=2378(,)\r
\r
# Change internal focus flag.\r
set void SetFocus=2380(bool focus,)\r
# Get internal focus flag.\r
get bool GetFocus=2381(,)\r
\r
enu Status=SC_STATUS_\r
val SC_STATUS_OK=0\r
val SC_STATUS_FAILURE=1\r
val SC_STATUS_BADALLOC=2\r
val SC_STATUS_WARN_START=1000\r
val SC_STATUS_WARN_REGEX=1001\r
\r
# Change error status - 0 = OK.\r
set void SetStatus=2382(int statusCode,)\r
# Get error status.\r
get int GetStatus=2383(,)\r
\r
# Set whether the mouse is captured when its button is pressed.\r
set void SetMouseDownCaptures=2384(bool captures,)\r
# Get whether mouse gets captured.\r
get bool GetMouseDownCaptures=2385(,)\r
\r
enu CursorShape=SC_CURSOR\r
val SC_CURSORNORMAL=-1\r
val SC_CURSORARROW=2\r
val SC_CURSORWAIT=4\r
val SC_CURSORREVERSEARROW=7\r
# Sets the cursor to one of the SC_CURSOR* values.\r
set void SetCursor=2386(int cursorType,)\r
# Get cursor type.\r
get int GetCursor=2387(,)\r
\r
# Change the way control characters are displayed:\r
# If symbol is < 32, keep the drawn way, else, use the given character.\r
set void SetControlCharSymbol=2388(int symbol,)\r
# Get the way control characters are displayed.\r
get int GetControlCharSymbol=2389(,)\r
\r
# Move to the previous change in capitalisation.\r
fun void WordPartLeft=2390(,)\r
# Move to the previous change in capitalisation extending selection\r
# to new caret position.\r
fun void WordPartLeftExtend=2391(,)\r
# Move to the change next in capitalisation.\r
fun void WordPartRight=2392(,)\r
# Move to the next change in capitalisation extending selection\r
# to new caret position.\r
fun void WordPartRightExtend=2393(,)\r
\r
# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.\r
val VISIBLE_SLOP=0x01\r
val VISIBLE_STRICT=0x04\r
# Set the way the display area is determined when a particular line\r
# is to be moved to by Find, FindNext, GotoLine, etc.\r
fun void SetVisiblePolicy=2394(int visiblePolicy, int visibleSlop)\r
\r
# Delete back from the current position to the start of the line.\r
fun void DelLineLeft=2395(,)\r
\r
# Delete forwards from the current position to the end of the line.\r
fun void DelLineRight=2396(,)\r
\r
# Get and Set the xOffset (ie, horizontal scroll position).\r
set void SetXOffset=2397(int newOffset,)\r
get int GetXOffset=2398(,)\r
\r
# Set the last x chosen value to be the caret x position.\r
fun void ChooseCaretX=2399(,)\r
\r
# Set the focus to this Scintilla widget.\r
fun void GrabFocus=2400(,)\r
\r
enu CaretPolicy=CARET_\r
# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.\r
# If CARET_SLOP is set, we can define a slop value: caretSlop.\r
# This value defines an unwanted zone (UZ) where the caret is... unwanted.\r
# This zone is defined as a number of pixels near the vertical margins,\r
# and as a number of lines near the horizontal margins.\r
# By keeping the caret away from the edges, it is seen within its context,\r
# so it is likely that the identifier that the caret is on can be completely seen,\r
# and that the current line is seen with some of the lines following it which are\r
# often dependent on that line.\r
val CARET_SLOP=0x01\r
# If CARET_STRICT is set, the policy is enforced... strictly.\r
# The caret is centred on the display if slop is not set,\r
# and cannot go in the UZ if slop is set.\r
val CARET_STRICT=0x04\r
# If CARET_JUMPS is set, the display is moved more energetically\r
# so the caret can move in the same direction longer before the policy is applied again.\r
val CARET_JUMPS=0x10\r
# If CARET_EVEN is not set, instead of having symmetrical UZs,\r
# the left and bottom UZs are extended up to right and top UZs respectively.\r
# This way, we favour the displaying of useful information: the beginning of lines,\r
# where most code reside, and the lines after the caret, eg. the body of a function.\r
val CARET_EVEN=0x08\r
\r
# Set the way the caret is kept visible when going sideways.\r
# The exclusion zone is given in pixels.\r
fun void SetXCaretPolicy=2402(int caretPolicy, int caretSlop)\r
\r
# Set the way the line the caret is on is kept visible.\r
# The exclusion zone is given in lines.\r
fun void SetYCaretPolicy=2403(int caretPolicy, int caretSlop)\r
\r
# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).\r
set void SetPrintWrapMode=2406(int mode,)\r
\r
# Is printing line wrapped?\r
get int GetPrintWrapMode=2407(,)\r
\r
# Set a fore colour for active hotspots.\r
set void SetHotspotActiveFore=2410(bool useSetting, colour fore)\r
\r
# Get the fore colour for active hotspots.\r
get colour GetHotspotActiveFore=2494(,)\r
\r
# Set a back colour for active hotspots.\r
set void SetHotspotActiveBack=2411(bool useSetting, colour back)\r
\r
# Get the back colour for active hotspots.\r
get colour GetHotspotActiveBack=2495(,)\r
\r
# Enable / Disable underlining active hotspots.\r
set void SetHotspotActiveUnderline=2412(bool underline,)\r
\r
# Get whether underlining for active hotspots.\r
get bool GetHotspotActiveUnderline=2496(,)\r
\r
# Limit hotspots to single line so hotspots on two lines don't merge.\r
set void SetHotspotSingleLine=2421(bool singleLine,)\r
\r
# Get the HotspotSingleLine property\r
get bool GetHotspotSingleLine=2497(,)\r
\r
# Move caret between paragraphs (delimited by empty lines).\r
fun void ParaDown=2413(,)\r
fun void ParaDownExtend=2414(,)\r
fun void ParaUp=2415(,)\r
fun void ParaUpExtend=2416(,)\r
\r
# Given a valid document position, return the previous position taking code\r
# page into account. Returns 0 if passed 0.\r
fun position PositionBefore=2417(position pos,)\r
\r
# Given a valid document position, return the next position taking code\r
# page into account. Maximum value returned is the last position in the document.\r
fun position PositionAfter=2418(position pos,)\r
\r
# Given a valid document position, return a position that differs in a number\r
# of characters. Returned value is always between 0 and last position in document.\r
fun position PositionRelative=2670(position pos, int relative)\r
\r
# Copy a range of text to the clipboard. Positions are clipped into the document.\r
fun void CopyRange=2419(position start, position end)\r
\r
# Copy argument text to the clipboard.\r
fun void CopyText=2420(int length, string text)\r
\r
enu SelectionMode=SC_SEL_\r
val SC_SEL_STREAM=0\r
val SC_SEL_RECTANGLE=1\r
val SC_SEL_LINES=2\r
val SC_SEL_THIN=3\r
\r
# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or\r
# by lines (SC_SEL_LINES).\r
set void SetSelectionMode=2422(int mode,)\r
\r
# Get the mode of the current selection.\r
get int GetSelectionMode=2423(,)\r
\r
# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).\r
fun position GetLineSelStartPosition=2424(int line,)\r
\r
# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).\r
fun position GetLineSelEndPosition=2425(int line,)\r
\r
## RectExtended rectangular selection moves\r
# Move caret down one line, extending rectangular selection to new caret position.\r
fun void LineDownRectExtend=2426(,)\r
\r
# Move caret up one line, extending rectangular selection to new caret position.\r
fun void LineUpRectExtend=2427(,)\r
\r
# Move caret left one character, extending rectangular selection to new caret position.\r
fun void CharLeftRectExtend=2428(,)\r
\r
# Move caret right one character, extending rectangular selection to new caret position.\r
fun void CharRightRectExtend=2429(,)\r
\r
# Move caret to first position on line, extending rectangular selection to new caret position.\r
fun void HomeRectExtend=2430(,)\r
\r
# Move caret to before first visible character on line.\r
# If already there move to first character on line.\r
# In either case, extend rectangular selection to new caret position.\r
fun void VCHomeRectExtend=2431(,)\r
\r
# Move caret to last position on line, extending rectangular selection to new caret position.\r
fun void LineEndRectExtend=2432(,)\r
\r
# Move caret one page up, extending rectangular selection to new caret position.\r
fun void PageUpRectExtend=2433(,)\r
\r
# Move caret one page down, extending rectangular selection to new caret position.\r
fun void PageDownRectExtend=2434(,)\r
\r
\r
# Move caret to top of page, or one page up if already at top of page.\r
fun void StutteredPageUp=2435(,)\r
\r
# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.\r
fun void StutteredPageUpExtend=2436(,)\r
\r
# Move caret to bottom of page, or one page down if already at bottom of page.\r
fun void StutteredPageDown=2437(,)\r
\r
# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.\r
fun void StutteredPageDownExtend=2438(,)\r
\r
\r
# Move caret left one word, position cursor at end of word.\r
fun void WordLeftEnd=2439(,)\r
\r
# Move caret left one word, position cursor at end of word, extending selection to new caret position.\r
fun void WordLeftEndExtend=2440(,)\r
\r
# Move caret right one word, position cursor at end of word.\r
fun void WordRightEnd=2441(,)\r
\r
# Move caret right one word, position cursor at end of word, extending selection to new caret position.\r
fun void WordRightEndExtend=2442(,)\r
\r
# Set the set of characters making up whitespace for when moving or selecting by word.\r
# Should be called after SetWordChars.\r
set void SetWhitespaceChars=2443(, string characters)\r
\r
# Get the set of characters making up whitespace for when moving or selecting by word.\r
get int GetWhitespaceChars=2647(, stringresult characters)\r
\r
# Set the set of characters making up punctuation characters\r
# Should be called after SetWordChars.\r
set void SetPunctuationChars=2648(, string characters)\r
\r
# Get the set of characters making up punctuation characters\r
get int GetPunctuationChars=2649(, stringresult characters)\r
\r
# Reset the set of characters for whitespace and word characters to the defaults.\r
fun void SetCharsDefault=2444(,)\r
\r
# Get currently selected item position in the auto-completion list\r
get int AutoCGetCurrent=2445(,)\r
\r
# Get currently selected item text in the auto-completion list\r
# Returns the length of the item text\r
# Result is NUL-terminated.\r
get int AutoCGetCurrentText=2610(, stringresult s)\r
\r
enu CaseInsensitiveBehaviour=SC_CASEINSENSITIVEBEHAVIOUR_\r
val SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE=0\r
val SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE=1\r
\r
# Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.\r
set void AutoCSetCaseInsensitiveBehaviour=2634(int behaviour,)\r
\r
# Get auto-completion case insensitive behaviour.\r
get int AutoCGetCaseInsensitiveBehaviour=2635(,)\r
\r
enu MultiAutoComplete=SC_MULTIAUTOC_\r
val SC_MULTIAUTOC_ONCE=0\r
val SC_MULTIAUTOC_EACH=1\r
\r
# Change the effect of autocompleting when there are multiple selections.\r
set void AutoCSetMulti=2636(int multi,)\r
\r
# Retrieve the effect of autocompleting when there are multiple selections..\r
get int AutoCGetMulti=2637(,)\r
\r
enu Ordering=SC_ORDER_\r
val SC_ORDER_PRESORTED=0\r
val SC_ORDER_PERFORMSORT=1\r
val SC_ORDER_CUSTOM=2\r
\r
# Set the way autocompletion lists are ordered.\r
set void AutoCSetOrder=2660(int order,)\r
\r
# Get the way autocompletion lists are ordered.\r
get int AutoCGetOrder=2661(,)\r
\r
# Enlarge the document to a particular size of text bytes.\r
fun void Allocate=2446(int bytes,)\r
\r
# Returns the target converted to UTF8.\r
# Return the length in bytes.\r
fun int TargetAsUTF8=2447(, stringresult s)\r
\r
# Set the length of the utf8 argument for calling EncodedFromUTF8.\r
# Set to -1 and the string will be measured to the first nul.\r
fun void SetLengthForEncode=2448(int bytes,)\r
\r
# Translates a UTF8 string into the document encoding.\r
# Return the length of the result in bytes.\r
# On error return 0.\r
fun int EncodedFromUTF8=2449(string utf8, stringresult encoded)\r
\r
# Find the position of a column on a line taking into account tabs and\r
# multi-byte characters. If beyond end of line, return line end position.\r
fun int FindColumn=2456(int line, int column)\r
\r
# Can the caret preferred x position only be changed by explicit movement commands?\r
get int GetCaretSticky=2457(,)\r
\r
# Stop the caret preferred x position changing when the user types.\r
set void SetCaretSticky=2458(int useCaretStickyBehaviour,)\r
\r
enu CaretSticky=SC_CARETSTICKY_\r
val SC_CARETSTICKY_OFF=0\r
val SC_CARETSTICKY_ON=1\r
val SC_CARETSTICKY_WHITESPACE=2\r
\r
# Switch between sticky and non-sticky: meant to be bound to a key.\r
fun void ToggleCaretSticky=2459(,)\r
\r
# Enable/Disable convert-on-paste for line endings\r
set void SetPasteConvertEndings=2467(bool convert,)\r
\r
# Get convert-on-paste setting\r
get bool GetPasteConvertEndings=2468(,)\r
\r
# Duplicate the selection. If selection empty duplicate the line containing the caret.\r
fun void SelectionDuplicate=2469(,)\r
\r
val SC_ALPHA_TRANSPARENT=0\r
val SC_ALPHA_OPAQUE=255\r
val SC_ALPHA_NOALPHA=256\r
\r
# Set background alpha of the caret line.\r
set void SetCaretLineBackAlpha=2470(int alpha,)\r
\r
# Get the background alpha of the caret line.\r
get int GetCaretLineBackAlpha=2471(,)\r
\r
enu CaretStyle=CARETSTYLE_\r
val CARETSTYLE_INVISIBLE=0\r
val CARETSTYLE_LINE=1\r
val CARETSTYLE_BLOCK=2\r
\r
# Set the style of the caret to be drawn.\r
set void SetCaretStyle=2512(int caretStyle,)\r
\r
# Returns the current style of the caret.\r
get int GetCaretStyle=2513(,)\r
\r
# Set the indicator used for IndicatorFillRange and IndicatorClearRange\r
set void SetIndicatorCurrent=2500(int indicator,)\r
\r
# Get the current indicator\r
get int GetIndicatorCurrent=2501(,)\r
\r
# Set the value used for IndicatorFillRange\r
set void SetIndicatorValue=2502(int value,)\r
\r
# Get the current indicator value\r
get int GetIndicatorValue=2503(,)\r
\r
# Turn a indicator on over a range.\r
fun void IndicatorFillRange=2504(int position, int fillLength)\r
\r
# Turn a indicator off over a range.\r
fun void IndicatorClearRange=2505(int position, int clearLength)\r
\r
# Are any indicators present at position?\r
fun int IndicatorAllOnFor=2506(int position,)\r
\r
# What value does a particular indicator have at at a position?\r
fun int IndicatorValueAt=2507(int indicator, int position)\r
\r
# Where does a particular indicator start?\r
fun int IndicatorStart=2508(int indicator, int position)\r
\r
# Where does a particular indicator end?\r
fun int IndicatorEnd=2509(int indicator, int position)\r
\r
# Set number of entries in position cache\r
set void SetPositionCache=2514(int size,)\r
\r
# How many entries are allocated to the position cache?\r
get int GetPositionCache=2515(,)\r
\r
# Copy the selection, if selection empty copy the line with the caret\r
fun void CopyAllowLine=2519(,)\r
\r
# Compact the document buffer and return a read-only pointer to the\r
# characters in the document.\r
get int GetCharacterPointer=2520(,)\r
\r
# Return a read-only pointer to a range of characters in the document.\r
# May move the gap so that the range is contiguous, but will only move up\r
# to rangeLength bytes.\r
get int GetRangePointer=2643(int position, int rangeLength)\r
\r
# Return a position which, to avoid performance costs, should not be within\r
# the range of a call to GetRangePointer.\r
get position GetGapPosition=2644(,)\r
\r
# Set the alpha fill colour of the given indicator.\r
set void IndicSetAlpha=2523(int indicator, int alpha)\r
\r
# Get the alpha fill colour of the given indicator.\r
get int IndicGetAlpha=2524(int indicator,)\r
\r
# Set the alpha outline colour of the given indicator.\r
set void IndicSetOutlineAlpha=2558(int indicator, int alpha)\r
\r
# Get the alpha outline colour of the given indicator.\r
get int IndicGetOutlineAlpha=2559(int indicator,)\r
\r
# Set extra ascent for each line\r
set void SetExtraAscent=2525(int extraAscent,)\r
\r
# Get extra ascent for each line\r
get int GetExtraAscent=2526(,)\r
\r
# Set extra descent for each line\r
set void SetExtraDescent=2527(int extraDescent,)\r
\r
# Get extra descent for each line\r
get int GetExtraDescent=2528(,)\r
\r
# Which symbol was defined for markerNumber with MarkerDefine\r
fun int MarkerSymbolDefined=2529(int markerNumber,)\r
\r
# Set the text in the text margin for a line\r
set void MarginSetText=2530(int line, string text)\r
\r
# Get the text in the text margin for a line\r
get int MarginGetText=2531(int line, stringresult text)\r
\r
# Set the style number for the text margin for a line\r
set void MarginSetStyle=2532(int line, int style)\r
\r
# Get the style number for the text margin for a line\r
get int MarginGetStyle=2533(int line,)\r
\r
# Set the style in the text margin for a line\r
set void MarginSetStyles=2534(int line, string styles)\r
\r
# Get the styles in the text margin for a line\r
get int MarginGetStyles=2535(int line, stringresult styles)\r
\r
# Clear the margin text on all lines\r
fun void MarginTextClearAll=2536(,)\r
\r
# Get the start of the range of style numbers used for margin text\r
set void MarginSetStyleOffset=2537(int style,)\r
\r
# Get the start of the range of style numbers used for margin text\r
get int MarginGetStyleOffset=2538(,)\r
\r
enu MarginOption=SC_MARGINOPTION_\r
val SC_MARGINOPTION_NONE=0\r
val SC_MARGINOPTION_SUBLINESELECT=1\r
\r
# Set the margin options.\r
set void SetMarginOptions=2539(int marginOptions,)\r
\r
# Get the margin options.\r
get int GetMarginOptions=2557(,)\r
\r
# Set the annotation text for a line\r
set void AnnotationSetText=2540(int line, string text)\r
\r
# Get the annotation text for a line\r
get int AnnotationGetText=2541(int line, stringresult text)\r
\r
# Set the style number for the annotations for a line\r
set void AnnotationSetStyle=2542(int line, int style)\r
\r
# Get the style number for the annotations for a line\r
get int AnnotationGetStyle=2543(int line,)\r
\r
# Set the annotation styles for a line\r
set void AnnotationSetStyles=2544(int line, string styles)\r
\r
# Get the annotation styles for a line\r
get int AnnotationGetStyles=2545(int line, stringresult styles)\r
\r
# Get the number of annotation lines for a line\r
get int AnnotationGetLines=2546(int line,)\r
\r
# Clear the annotations from all lines\r
fun void AnnotationClearAll=2547(,)\r
\r
enu AnnotationVisible=ANNOTATION_\r
val ANNOTATION_HIDDEN=0\r
val ANNOTATION_STANDARD=1\r
val ANNOTATION_BOXED=2\r
val ANNOTATION_INDENTED=3\r
\r
# Set the visibility for the annotations for a view\r
set void AnnotationSetVisible=2548(int visible,)\r
\r
# Get the visibility for the annotations for a view\r
get int AnnotationGetVisible=2549(,)\r
\r
# Get the start of the range of style numbers used for annotations\r
set void AnnotationSetStyleOffset=2550(int style,)\r
\r
# Get the start of the range of style numbers used for annotations\r
get int AnnotationGetStyleOffset=2551(,)\r
\r
# Release all extended (>255) style numbers\r
fun void ReleaseAllExtendedStyles=2552(,)\r
\r
# Allocate some extended (>255) style numbers and return the start of the range\r
fun int AllocateExtendedStyles=2553(int numberStyles,)\r
\r
val UNDO_MAY_COALESCE=1\r
\r
# Add a container action to the undo stack\r
fun void AddUndoAction=2560(int token, int flags)\r
\r
# Find the position of a character from a point within the window.\r
fun position CharPositionFromPoint=2561(int x, int y)\r
\r
# Find the position of a character from a point within the window.\r
# Return INVALID_POSITION if not close to text.\r
fun position CharPositionFromPointClose=2562(int x, int y)\r
\r
# Set whether switching to rectangular mode while selecting with the mouse is allowed.\r
set void SetMouseSelectionRectangularSwitch=2668(bool mouseSelectionRectangularSwitch,)\r
\r
# Whether switching to rectangular mode while selecting with the mouse is allowed.\r
get bool GetMouseSelectionRectangularSwitch=2669(,)\r
\r
# Set whether multiple selections can be made\r
set void SetMultipleSelection=2563(bool multipleSelection,)\r
\r
# Whether multiple selections can be made\r
get bool GetMultipleSelection=2564(,)\r
\r
# Set whether typing can be performed into multiple selections\r
set void SetAdditionalSelectionTyping=2565(bool additionalSelectionTyping,)\r
\r
# Whether typing can be performed into multiple selections\r
get bool GetAdditionalSelectionTyping=2566(,)\r
\r
# Set whether additional carets will blink\r
set void SetAdditionalCaretsBlink=2567(bool additionalCaretsBlink,)\r
\r
# Whether additional carets will blink\r
get bool GetAdditionalCaretsBlink=2568(,)\r
\r
# Set whether additional carets are visible\r
set void SetAdditionalCaretsVisible=2608(bool additionalCaretsBlink,)\r
\r
# Whether additional carets are visible\r
get bool GetAdditionalCaretsVisible=2609(,)\r
\r
# How many selections are there?\r
get int GetSelections=2570(,)\r
\r
# Is every selected range empty?\r
get bool GetSelectionEmpty=2650(,)\r
\r
# Clear selections to a single empty stream selection\r
fun void ClearSelections=2571(,)\r
\r
# Set a simple selection\r
fun int SetSelection=2572(int caret, int anchor)\r
\r
# Add a selection\r
fun int AddSelection=2573(int caret, int anchor)\r
\r
# Drop one selection\r
fun void DropSelectionN=2671(int selection,)\r
\r
# Set the main selection\r
set void SetMainSelection=2574(int selection,)\r
\r
# Which selection is the main selection\r
get int GetMainSelection=2575(,)\r
\r
set void SetSelectionNCaret=2576(int selection, position pos)\r
get position GetSelectionNCaret=2577(int selection,)\r
set void SetSelectionNAnchor=2578(int selection, position posAnchor)\r
get position GetSelectionNAnchor=2579(int selection,)\r
set void SetSelectionNCaretVirtualSpace=2580(int selection, int space)\r
get int GetSelectionNCaretVirtualSpace=2581(int selection,)\r
set void SetSelectionNAnchorVirtualSpace=2582(int selection, int space)\r
get int GetSelectionNAnchorVirtualSpace=2583(int selection,)\r
\r
# Sets the position that starts the selection - this becomes the anchor.\r
set void SetSelectionNStart=2584(int selection, position pos)\r
\r
# Returns the position at the start of the selection.\r
get position GetSelectionNStart=2585(int selection,)\r
\r
# Sets the position that ends the selection - this becomes the currentPosition.\r
set void SetSelectionNEnd=2586(int selection, position pos)\r
\r
# Returns the position at the end of the selection.\r
get position GetSelectionNEnd=2587(int selection,)\r
\r
set void SetRectangularSelectionCaret=2588(position pos,)\r
get position GetRectangularSelectionCaret=2589(,)\r
set void SetRectangularSelectionAnchor=2590(position posAnchor,)\r
get position GetRectangularSelectionAnchor=2591(,)\r
set void SetRectangularSelectionCaretVirtualSpace=2592(int space,)\r
get int GetRectangularSelectionCaretVirtualSpace=2593(,)\r
set void SetRectangularSelectionAnchorVirtualSpace=2594(int space,)\r
get int GetRectangularSelectionAnchorVirtualSpace=2595(,)\r
\r
enu VirtualSpace=SCVS_\r
val SCVS_NONE=0\r
val SCVS_RECTANGULARSELECTION=1\r
val SCVS_USERACCESSIBLE=2\r
\r
set void SetVirtualSpaceOptions=2596(int virtualSpaceOptions,)\r
get int GetVirtualSpaceOptions=2597(,)\r
\r
# On GTK+, allow selecting the modifier key to use for mouse-based\r
# rectangular selection. Often the window manager requires Alt+Mouse Drag\r
# for moving windows.\r
# Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.\r
\r
set void SetRectangularSelectionModifier=2598(int modifier,)\r
\r
# Get the modifier key used for rectangular selection.\r
get int GetRectangularSelectionModifier=2599(,)\r
\r
# Set the foreground colour of additional selections.\r
# Must have previously called SetSelFore with non-zero first argument for this to have an effect.\r
set void SetAdditionalSelFore=2600(colour fore,)\r
\r
# Set the background colour of additional selections.\r
# Must have previously called SetSelBack with non-zero first argument for this to have an effect.\r
set void SetAdditionalSelBack=2601(colour back,)\r
\r
# Set the alpha of the selection.\r
set void SetAdditionalSelAlpha=2602(int alpha,)\r
\r
# Get the alpha of the selection.\r
get int GetAdditionalSelAlpha=2603(,)\r
\r
# Set the foreground colour of additional carets.\r
set void SetAdditionalCaretFore=2604(colour fore,)\r
\r
# Get the foreground colour of additional carets.\r
get colour GetAdditionalCaretFore=2605(,)\r
\r
# Set the main selection to the next selection.\r
fun void RotateSelection=2606(,)\r
\r
# Swap that caret and anchor of the main selection.\r
fun void SwapMainAnchorCaret=2607(,)\r
\r
# Add the next occurrence of the main selection to the set of selections as main.\r
# If the current selection is empty then select word around caret.\r
fun void MultipleSelectAddNext=2688(,)\r
\r
# Add each occurrence of the main selection in the target to the set of selections.\r
# If the current selection is empty then select word around caret.\r
fun void MultipleSelectAddEach=2689(,)\r
\r
# Indicate that the internal state of a lexer has changed over a range and therefore\r
# there may be a need to redraw.\r
fun int ChangeLexerState=2617(position start, position end)\r
\r
# Find the next line at or after lineStart that is a contracted fold header line.\r
# Return -1 when no more lines.\r
fun int ContractedFoldNext=2618(int lineStart,)\r
\r
# Centre current line in window.\r
fun void VerticalCentreCaret=2619(,)\r
\r
# Move the selected lines up one line, shifting the line above after the selection\r
fun void MoveSelectedLinesUp=2620(,)\r
\r
# Move the selected lines down one line, shifting the line below before the selection\r
fun void MoveSelectedLinesDown=2621(,)\r
\r
# Set the identifier reported as idFrom in notification messages.\r
set void SetIdentifier=2622(int identifier,)\r
\r
# Get the identifier.\r
get int GetIdentifier=2623(,)\r
\r
# Set the width for future RGBA image data.\r
set void RGBAImageSetWidth=2624(int width,)\r
\r
# Set the height for future RGBA image data.\r
set void RGBAImageSetHeight=2625(int height,)\r
\r
# Set the scale factor in percent for future RGBA image data.\r
set void RGBAImageSetScale=2651(int scalePercent,)\r
\r
# Define a marker from RGBA data.\r
# It has the width and height from RGBAImageSetWidth/Height\r
fun void MarkerDefineRGBAImage=2626(int markerNumber, string pixels)\r
\r
# Register an RGBA image for use in autocompletion lists.\r
# It has the width and height from RGBAImageSetWidth/Height\r
fun void RegisterRGBAImage=2627(int type, string pixels)\r
\r
# Scroll to start of document.\r
fun void ScrollToStart=2628(,)\r
\r
# Scroll to end of document.\r
fun void ScrollToEnd=2629(,)\r
\r
val SC_TECHNOLOGY_DEFAULT=0\r
val SC_TECHNOLOGY_DIRECTWRITE=1\r
val SC_TECHNOLOGY_DIRECTWRITERETAIN=2\r
val SC_TECHNOLOGY_DIRECTWRITEDC=3\r
\r
# Set the technology used.\r
set void SetTechnology=2630(int technology,)\r
\r
# Get the tech.\r
get int GetTechnology=2631(,)\r
\r
# Create an ILoader*.\r
fun int CreateLoader=2632(int bytes,)\r
\r
# On OS X, show a find indicator.\r
fun void FindIndicatorShow=2640(position start, position end)\r
\r
# On OS X, flash a find indicator, then fade out.\r
fun void FindIndicatorFlash=2641(position start, position end)\r
\r
# On OS X, hide the find indicator.\r
fun void FindIndicatorHide=2642(,)\r
\r
# Move caret to before first visible character on display line.\r
# If already there move to first character on display line.\r
fun void VCHomeDisplay=2652(,)\r
\r
# Like VCHomeDisplay but extending selection to new caret position.\r
fun void VCHomeDisplayExtend=2653(,)\r
\r
# Is the caret line always visible?\r
get bool GetCaretLineVisibleAlways=2654(,)\r
\r
# Sets the caret line to always visible.\r
set void SetCaretLineVisibleAlways=2655(bool alwaysVisible,)\r
\r
# Line end types which may be used in addition to LF, CR, and CRLF\r
# SC_LINE_END_TYPE_UNICODE includes U+2028 Line Separator,\r
# U+2029 Paragraph Separator, and U+0085 Next Line\r
enu LineEndType=SC_LINE_END_TYPE_\r
val SC_LINE_END_TYPE_DEFAULT=0\r
val SC_LINE_END_TYPE_UNICODE=1\r
\r
# Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.\r
set void SetLineEndTypesAllowed=2656(int lineEndBitSet,)\r
\r
# Get the line end types currently allowed.\r
get int GetLineEndTypesAllowed=2657(,)\r
\r
# Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.\r
get int GetLineEndTypesActive=2658(,)\r
\r
# Set the way a character is drawn.\r
set void SetRepresentation=2665(string encodedCharacter, string representation)\r
\r
# Set the way a character is drawn.\r
# Result is NUL-terminated.\r
get int GetRepresentation=2666(string encodedCharacter, stringresult representation)\r
\r
# Remove a character representation.\r
fun void ClearRepresentation=2667(string encodedCharacter,)\r
\r
# Start notifying the container of all key presses and commands.\r
fun void StartRecord=3001(,)\r
\r
# Stop notifying the container of all key presses and commands.\r
fun void StopRecord=3002(,)\r
\r
# Set the lexing language of the document.\r
set void SetLexer=4001(int lexer,)\r
\r
# Retrieve the lexing language of the document.\r
get int GetLexer=4002(,)\r
\r
# Colourise a segment of the document using the current lexing language.\r
fun void Colourise=4003(position start, position end)\r
\r
# Set up a value that may be used by a lexer for some optional feature.\r
set void SetProperty=4004(string key, string value)\r
\r
# Maximum value of keywordSet parameter of SetKeyWords.\r
val KEYWORDSET_MAX=8\r
\r
# Set up the key words used by the lexer.\r
set void SetKeyWords=4005(int keywordSet, string keyWords)\r
\r
# Set the lexing language of the document based on string name.\r
set void SetLexerLanguage=4006(, string language)\r
\r
# Load a lexer library (dll / so).\r
fun void LoadLexerLibrary=4007(, string path)\r
\r
# Retrieve a "property" value previously set with SetProperty.\r
# Result is NUL-terminated.\r
get int GetProperty=4008(string key, stringresult buf)\r
\r
# Retrieve a "property" value previously set with SetProperty,\r
# with "$()" variable replacement on returned buffer.\r
# Result is NUL-terminated.\r
get int GetPropertyExpanded=4009(string key, stringresult buf)\r
\r
# Retrieve a "property" value previously set with SetProperty,\r
# interpreted as an int AFTER any "$()" variable replacement.\r
get int GetPropertyInt=4010(string key,)\r
\r
# Retrieve the number of bits the current lexer needs for styling.\r
get int GetStyleBitsNeeded=4011(,)\r
\r
# Retrieve the name of the lexer.\r
# Return the length of the text.\r
# Result is NUL-terminated.\r
get int GetLexerLanguage=4012(, stringresult text)\r
\r
# For private communication between an application and a known lexer.\r
fun int PrivateLexerCall=4013(int operation, int pointer)\r
\r
# Retrieve a '\n' separated list of properties understood by the current lexer.\r
# Result is NUL-terminated.\r
fun int PropertyNames=4014(, stringresult names)\r
\r
enu TypeProperty=SC_TYPE_\r
val SC_TYPE_BOOLEAN=0\r
val SC_TYPE_INTEGER=1\r
val SC_TYPE_STRING=2\r
\r
# Retrieve the type of a property.\r
fun int PropertyType=4015(string name,)\r
\r
# Describe a property.\r
# Result is NUL-terminated.\r
fun int DescribeProperty=4016(string name, stringresult description)\r
\r
# Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.\r
# Result is NUL-terminated.\r
fun int DescribeKeyWordSets=4017(, stringresult descriptions)\r
\r
# Bit set of LineEndType enumertion for which line ends beyond the standard\r
# LF, CR, and CRLF are supported by the lexer.\r
get int GetLineEndTypesSupported=4018(,)\r
\r
# Allocate a set of sub styles for a particular base style, returning start of range\r
fun int AllocateSubStyles=4020(int styleBase, int numberStyles)\r
\r
# The starting style number for the sub styles associated with a base style\r
get int GetSubStylesStart=4021(int styleBase,)\r
\r
# The number of sub styles associated with a base style\r
get int GetSubStylesLength=4022(int styleBase,)\r
\r
# For a sub style, return the base style, else return the argument.\r
get int GetStyleFromSubStyle=4027(int subStyle,)\r
\r
# For a secondary style, return the primary style, else return the argument.\r
get int GetPrimaryStyleFromStyle=4028(int style,)\r
\r
# Free allocated sub styles\r
fun void FreeSubStyles=4023(,)\r
\r
# Set the identifiers that are shown in a particular style\r
set void SetIdentifiers=4024(int style, string identifiers)\r
\r
# Where styles are duplicated by a feature such as active/inactive code\r
# return the distance between the two types.\r
get int DistanceToSecondaryStyles=4025(,)\r
\r
# Get the set of base styles that can be extended with sub styles\r
# Result is NUL-terminated.\r
get int GetSubStyleBases=4026(, stringresult styles)\r
\r
# Notifications\r
# Type of modification and the action which caused the modification.\r
# These are defined as a bit mask to make it easy to specify which notifications are wanted.\r
# One bit is set from each of SC_MOD_* and SC_PERFORMED_*.\r
enu ModificationFlags=SC_MOD_ SC_PERFORMED_ SC_MULTISTEPUNDOREDO SC_LASTSTEPINUNDOREDO SC_MULTILINEUNDOREDO SC_STARTACTION SC_MODEVENTMASKALL\r
val SC_MOD_INSERTTEXT=0x1\r
val SC_MOD_DELETETEXT=0x2\r
val SC_MOD_CHANGESTYLE=0x4\r
val SC_MOD_CHANGEFOLD=0x8\r
val SC_PERFORMED_USER=0x10\r
val SC_PERFORMED_UNDO=0x20\r
val SC_PERFORMED_REDO=0x40\r
val SC_MULTISTEPUNDOREDO=0x80\r
val SC_LASTSTEPINUNDOREDO=0x100\r
val SC_MOD_CHANGEMARKER=0x200\r
val SC_MOD_BEFOREINSERT=0x400\r
val SC_MOD_BEFOREDELETE=0x800\r
val SC_MULTILINEUNDOREDO=0x1000\r
val SC_STARTACTION=0x2000\r
val SC_MOD_CHANGEINDICATOR=0x4000\r
val SC_MOD_CHANGELINESTATE=0x8000\r
val SC_MOD_CHANGEMARGIN=0x10000\r
val SC_MOD_CHANGEANNOTATION=0x20000\r
val SC_MOD_CONTAINER=0x40000\r
val SC_MOD_LEXERSTATE=0x80000\r
val SC_MOD_INSERTCHECK=0x100000\r
val SC_MOD_CHANGETABSTOPS=0x200000\r
val SC_MODEVENTMASKALL=0x3FFFFF\r
\r
enu Update=SC_UPDATE_\r
val SC_UPDATE_CONTENT=0x1\r
val SC_UPDATE_SELECTION=0x2\r
val SC_UPDATE_V_SCROLL=0x4\r
val SC_UPDATE_H_SCROLL=0x8\r
\r
# For compatibility, these go through the COMMAND notification rather than NOTIFY\r
# and should have had exactly the same values as the EN_* constants.\r
# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_*\r
# As clients depend on these constants, this will not be changed.\r
val SCEN_CHANGE=768\r
val SCEN_SETFOCUS=512\r
val SCEN_KILLFOCUS=256\r
\r
# Symbolic key codes and modifier flags.\r
# ASCII and other printable characters below 256.\r
# Extended keys above 300.\r
\r
enu Keys=SCK_\r
val SCK_DOWN=300\r
val SCK_UP=301\r
val SCK_LEFT=302\r
val SCK_RIGHT=303\r
val SCK_HOME=304\r
val SCK_END=305\r
val SCK_PRIOR=306\r
val SCK_NEXT=307\r
val SCK_DELETE=308\r
val SCK_INSERT=309\r
val SCK_ESCAPE=7\r
val SCK_BACK=8\r
val SCK_TAB=9\r
val SCK_RETURN=13\r
val SCK_ADD=310\r
val SCK_SUBTRACT=311\r
val SCK_DIVIDE=312\r
val SCK_WIN=313\r
val SCK_RWIN=314\r
val SCK_MENU=315\r
\r
enu KeyMod=SCMOD_\r
val SCMOD_NORM=0\r
val SCMOD_SHIFT=1\r
val SCMOD_CTRL=2\r
val SCMOD_ALT=4\r
val SCMOD_SUPER=8\r
val SCMOD_META=16\r
\r
################################################\r
# For SciLexer.h\r
enu Lexer=SCLEX_\r
val SCLEX_CONTAINER=0\r
val SCLEX_NULL=1\r
val SCLEX_PYTHON=2\r
val SCLEX_CPP=3\r
val SCLEX_HTML=4\r
val SCLEX_XML=5\r
val SCLEX_PERL=6\r
val SCLEX_SQL=7\r
val SCLEX_VB=8\r
val SCLEX_PROPERTIES=9\r
val SCLEX_ERRORLIST=10\r
val SCLEX_MAKEFILE=11\r
val SCLEX_BATCH=12\r
val SCLEX_XCODE=13\r
val SCLEX_LATEX=14\r
val SCLEX_LUA=15\r
val SCLEX_DIFF=16\r
val SCLEX_CONF=17\r
val SCLEX_PASCAL=18\r
val SCLEX_AVE=19\r
val SCLEX_ADA=20\r
val SCLEX_LISP=21\r
val SCLEX_RUBY=22\r
val SCLEX_EIFFEL=23\r
val SCLEX_EIFFELKW=24\r
val SCLEX_TCL=25\r
val SCLEX_NNCRONTAB=26\r
val SCLEX_BULLANT=27\r
val SCLEX_VBSCRIPT=28\r
val SCLEX_BAAN=31\r
val SCLEX_MATLAB=32\r
val SCLEX_SCRIPTOL=33\r
val SCLEX_ASM=34\r
val SCLEX_CPPNOCASE=35\r
val SCLEX_FORTRAN=36\r
val SCLEX_F77=37\r
val SCLEX_CSS=38\r
val SCLEX_POV=39\r
val SCLEX_LOUT=40\r
val SCLEX_ESCRIPT=41\r
val SCLEX_PS=42\r
val SCLEX_NSIS=43\r
val SCLEX_MMIXAL=44\r
val SCLEX_CLW=45\r
val SCLEX_CLWNOCASE=46\r
val SCLEX_LOT=47\r
val SCLEX_YAML=48\r
val SCLEX_TEX=49\r
val SCLEX_METAPOST=50\r
val SCLEX_POWERBASIC=51\r
val SCLEX_FORTH=52\r
val SCLEX_ERLANG=53\r
val SCLEX_OCTAVE=54\r
val SCLEX_MSSQL=55\r
val SCLEX_VERILOG=56\r
val SCLEX_KIX=57\r
val SCLEX_GUI4CLI=58\r
val SCLEX_SPECMAN=59\r
val SCLEX_AU3=60\r
val SCLEX_APDL=61\r
val SCLEX_BASH=62\r
val SCLEX_ASN1=63\r
val SCLEX_VHDL=64\r
val SCLEX_CAML=65\r
val SCLEX_BLITZBASIC=66\r
val SCLEX_PUREBASIC=67\r
val SCLEX_HASKELL=68\r
val SCLEX_PHPSCRIPT=69\r
val SCLEX_TADS3=70\r
val SCLEX_REBOL=71\r
val SCLEX_SMALLTALK=72\r
val SCLEX_FLAGSHIP=73\r
val SCLEX_CSOUND=74\r
val SCLEX_FREEBASIC=75\r
val SCLEX_INNOSETUP=76\r
val SCLEX_OPAL=77\r
val SCLEX_SPICE=78\r
val SCLEX_D=79\r
val SCLEX_CMAKE=80\r
val SCLEX_GAP=81\r
val SCLEX_PLM=82\r
val SCLEX_PROGRESS=83\r
val SCLEX_ABAQUS=84\r
val SCLEX_ASYMPTOTE=85\r
val SCLEX_R=86\r
val SCLEX_MAGIK=87\r
val SCLEX_POWERSHELL=88\r
val SCLEX_MYSQL=89\r
val SCLEX_PO=90\r
val SCLEX_TAL=91\r
val SCLEX_COBOL=92\r
val SCLEX_TACL=93\r
val SCLEX_SORCUS=94\r
val SCLEX_POWERPRO=95\r
val SCLEX_NIMROD=96\r
val SCLEX_SML=97\r
val SCLEX_MARKDOWN=98\r
val SCLEX_TXT2TAGS=99\r
val SCLEX_A68K=100\r
val SCLEX_MODULA=101\r
val SCLEX_COFFEESCRIPT=102\r
val SCLEX_TCMD=103\r
val SCLEX_AVS=104\r
val SCLEX_ECL=105\r
val SCLEX_OSCRIPT=106\r
val SCLEX_VISUALPROLOG=107\r
val SCLEX_LITERATEHASKELL=108\r
val SCLEX_STTXT=109\r
val SCLEX_KVIRC=110\r
val SCLEX_RUST=111\r
val SCLEX_DMAP=112\r
val SCLEX_AS=113\r
val SCLEX_DMIS=114\r
val SCLEX_REGISTRY=115\r
val SCLEX_BIBTEX=116\r
val SCLEX_SREC=117\r
val SCLEX_IHEX=118\r
val SCLEX_TEHEX=119\r
\r
# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a\r
# value assigned in sequence from SCLEX_AUTOMATIC+1.\r
val SCLEX_AUTOMATIC=1000\r
# Lexical states for SCLEX_PYTHON\r
lex Python=SCLEX_PYTHON SCE_P_\r
lex Nimrod=SCLEX_NIMROD SCE_P_\r
val SCE_P_DEFAULT=0\r
val SCE_P_COMMENTLINE=1\r
val SCE_P_NUMBER=2\r
val SCE_P_STRING=3\r
val SCE_P_CHARACTER=4\r
val SCE_P_WORD=5\r
val SCE_P_TRIPLE=6\r
val SCE_P_TRIPLEDOUBLE=7\r
val SCE_P_CLASSNAME=8\r
val SCE_P_DEFNAME=9\r
val SCE_P_OPERATOR=10\r
val SCE_P_IDENTIFIER=11\r
val SCE_P_COMMENTBLOCK=12\r
val SCE_P_STRINGEOL=13\r
val SCE_P_WORD2=14\r
val SCE_P_DECORATOR=15\r
# Lexical states for SCLEX_CPP\r
lex Cpp=SCLEX_CPP SCE_C_\r
lex BullAnt=SCLEX_BULLANT SCE_C_\r
val SCE_C_DEFAULT=0\r
val SCE_C_COMMENT=1\r
val SCE_C_COMMENTLINE=2\r
val SCE_C_COMMENTDOC=3\r
val SCE_C_NUMBER=4\r
val SCE_C_WORD=5\r
val SCE_C_STRING=6\r
val SCE_C_CHARACTER=7\r
val SCE_C_UUID=8\r
val SCE_C_PREPROCESSOR=9\r
val SCE_C_OPERATOR=10\r
val SCE_C_IDENTIFIER=11\r
val SCE_C_STRINGEOL=12\r
val SCE_C_VERBATIM=13\r
val SCE_C_REGEX=14\r
val SCE_C_COMMENTLINEDOC=15\r
val SCE_C_WORD2=16\r
val SCE_C_COMMENTDOCKEYWORD=17\r
val SCE_C_COMMENTDOCKEYWORDERROR=18\r
val SCE_C_GLOBALCLASS=19\r
val SCE_C_STRINGRAW=20\r
val SCE_C_TRIPLEVERBATIM=21\r
val SCE_C_HASHQUOTEDSTRING=22\r
val SCE_C_PREPROCESSORCOMMENT=23\r
val SCE_C_PREPROCESSORCOMMENTDOC=24\r
val SCE_C_USERLITERAL=25\r
val SCE_C_TASKMARKER=26\r
val SCE_C_ESCAPESEQUENCE=27\r
# Lexical states for SCLEX_D\r
lex D=SCLEX_D SCE_D_\r
val SCE_D_DEFAULT=0\r
val SCE_D_COMMENT=1\r
val SCE_D_COMMENTLINE=2\r
val SCE_D_COMMENTDOC=3\r
val SCE_D_COMMENTNESTED=4\r
val SCE_D_NUMBER=5\r
val SCE_D_WORD=6\r
val SCE_D_WORD2=7\r
val SCE_D_WORD3=8\r
val SCE_D_TYPEDEF=9\r
val SCE_D_STRING=10\r
val SCE_D_STRINGEOL=11\r
val SCE_D_CHARACTER=12\r
val SCE_D_OPERATOR=13\r
val SCE_D_IDENTIFIER=14\r
val SCE_D_COMMENTLINEDOC=15\r
val SCE_D_COMMENTDOCKEYWORD=16\r
val SCE_D_COMMENTDOCKEYWORDERROR=17\r
val SCE_D_STRINGB=18\r
val SCE_D_STRINGR=19\r
val SCE_D_WORD5=20\r
val SCE_D_WORD6=21\r
val SCE_D_WORD7=22\r
# Lexical states for SCLEX_TCL\r
lex TCL=SCLEX_TCL SCE_TCL_\r
val SCE_TCL_DEFAULT=0\r
val SCE_TCL_COMMENT=1\r
val SCE_TCL_COMMENTLINE=2\r
val SCE_TCL_NUMBER=3\r
val SCE_TCL_WORD_IN_QUOTE=4\r
val SCE_TCL_IN_QUOTE=5\r
val SCE_TCL_OPERATOR=6\r
val SCE_TCL_IDENTIFIER=7\r
val SCE_TCL_SUBSTITUTION=8\r
val SCE_TCL_SUB_BRACE=9\r
val SCE_TCL_MODIFIER=10\r
val SCE_TCL_EXPAND=11\r
val SCE_TCL_WORD=12\r
val SCE_TCL_WORD2=13\r
val SCE_TCL_WORD3=14\r
val SCE_TCL_WORD4=15\r
val SCE_TCL_WORD5=16\r
val SCE_TCL_WORD6=17\r
val SCE_TCL_WORD7=18\r
val SCE_TCL_WORD8=19\r
val SCE_TCL_COMMENT_BOX=20\r
val SCE_TCL_BLOCK_COMMENT=21\r
# Lexical states for SCLEX_HTML, SCLEX_XML\r
lex HTML=SCLEX_HTML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_\r
lex XML=SCLEX_XML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_\r
val SCE_H_DEFAULT=0\r
val SCE_H_TAG=1\r
val SCE_H_TAGUNKNOWN=2\r
val SCE_H_ATTRIBUTE=3\r
val SCE_H_ATTRIBUTEUNKNOWN=4\r
val SCE_H_NUMBER=5\r
val SCE_H_DOUBLESTRING=6\r
val SCE_H_SINGLESTRING=7\r
val SCE_H_OTHER=8\r
val SCE_H_COMMENT=9\r
val SCE_H_ENTITY=10\r
# XML and ASP\r
val SCE_H_TAGEND=11\r
val SCE_H_XMLSTART=12\r
val SCE_H_XMLEND=13\r
val SCE_H_SCRIPT=14\r
val SCE_H_ASP=15\r
val SCE_H_ASPAT=16\r
val SCE_H_CDATA=17\r
val SCE_H_QUESTION=18\r
# More HTML\r
val SCE_H_VALUE=19\r
# X-Code\r
val SCE_H_XCCOMMENT=20\r
# SGML\r
val SCE_H_SGML_DEFAULT=21\r
val SCE_H_SGML_COMMAND=22\r
val SCE_H_SGML_1ST_PARAM=23\r
val SCE_H_SGML_DOUBLESTRING=24\r
val SCE_H_SGML_SIMPLESTRING=25\r
val SCE_H_SGML_ERROR=26\r
val SCE_H_SGML_SPECIAL=27\r
val SCE_H_SGML_ENTITY=28\r
val SCE_H_SGML_COMMENT=29\r
val SCE_H_SGML_1ST_PARAM_COMMENT=30\r
val SCE_H_SGML_BLOCK_DEFAULT=31\r
# Embedded Javascript\r
val SCE_HJ_START=40\r
val SCE_HJ_DEFAULT=41\r
val SCE_HJ_COMMENT=42\r
val SCE_HJ_COMMENTLINE=43\r
val SCE_HJ_COMMENTDOC=44\r
val SCE_HJ_NUMBER=45\r
val SCE_HJ_WORD=46\r
val SCE_HJ_KEYWORD=47\r
val SCE_HJ_DOUBLESTRING=48\r
val SCE_HJ_SINGLESTRING=49\r
val SCE_HJ_SYMBOLS=50\r
val SCE_HJ_STRINGEOL=51\r
val SCE_HJ_REGEX=52\r
# ASP Javascript\r
val SCE_HJA_START=55\r
val SCE_HJA_DEFAULT=56\r
val SCE_HJA_COMMENT=57\r
val SCE_HJA_COMMENTLINE=58\r
val SCE_HJA_COMMENTDOC=59\r
val SCE_HJA_NUMBER=60\r
val SCE_HJA_WORD=61\r
val SCE_HJA_KEYWORD=62\r
val SCE_HJA_DOUBLESTRING=63\r
val SCE_HJA_SINGLESTRING=64\r
val SCE_HJA_SYMBOLS=65\r
val SCE_HJA_STRINGEOL=66\r
val SCE_HJA_REGEX=67\r
# Embedded VBScript\r
val SCE_HB_START=70\r
val SCE_HB_DEFAULT=71\r
val SCE_HB_COMMENTLINE=72\r
val SCE_HB_NUMBER=73\r
val SCE_HB_WORD=74\r
val SCE_HB_STRING=75\r
val SCE_HB_IDENTIFIER=76\r
val SCE_HB_STRINGEOL=77\r
# ASP VBScript\r
val SCE_HBA_START=80\r
val SCE_HBA_DEFAULT=81\r
val SCE_HBA_COMMENTLINE=82\r
val SCE_HBA_NUMBER=83\r
val SCE_HBA_WORD=84\r
val SCE_HBA_STRING=85\r
val SCE_HBA_IDENTIFIER=86\r
val SCE_HBA_STRINGEOL=87\r
# Embedded Python\r
val SCE_HP_START=90\r
val SCE_HP_DEFAULT=91\r
val SCE_HP_COMMENTLINE=92\r
val SCE_HP_NUMBER=93\r
val SCE_HP_STRING=94\r
val SCE_HP_CHARACTER=95\r
val SCE_HP_WORD=96\r
val SCE_HP_TRIPLE=97\r
val SCE_HP_TRIPLEDOUBLE=98\r
val SCE_HP_CLASSNAME=99\r
val SCE_HP_DEFNAME=100\r
val SCE_HP_OPERATOR=101\r
val SCE_HP_IDENTIFIER=102\r
# PHP\r
val SCE_HPHP_COMPLEX_VARIABLE=104\r
# ASP Python\r
val SCE_HPA_START=105\r
val SCE_HPA_DEFAULT=106\r
val SCE_HPA_COMMENTLINE=107\r
val SCE_HPA_NUMBER=108\r
val SCE_HPA_STRING=109\r
val SCE_HPA_CHARACTER=110\r
val SCE_HPA_WORD=111\r
val SCE_HPA_TRIPLE=112\r
val SCE_HPA_TRIPLEDOUBLE=113\r
val SCE_HPA_CLASSNAME=114\r
val SCE_HPA_DEFNAME=115\r
val SCE_HPA_OPERATOR=116\r
val SCE_HPA_IDENTIFIER=117\r
# PHP\r
val SCE_HPHP_DEFAULT=118\r
val SCE_HPHP_HSTRING=119\r
val SCE_HPHP_SIMPLESTRING=120\r
val SCE_HPHP_WORD=121\r
val SCE_HPHP_NUMBER=122\r
val SCE_HPHP_VARIABLE=123\r
val SCE_HPHP_COMMENT=124\r
val SCE_HPHP_COMMENTLINE=125\r
val SCE_HPHP_HSTRING_VARIABLE=126\r
val SCE_HPHP_OPERATOR=127\r
# Lexical states for SCLEX_PERL\r
lex Perl=SCLEX_PERL SCE_PL_\r
val SCE_PL_DEFAULT=0\r
val SCE_PL_ERROR=1\r
val SCE_PL_COMMENTLINE=2\r
val SCE_PL_POD=3\r
val SCE_PL_NUMBER=4\r
val SCE_PL_WORD=5\r
val SCE_PL_STRING=6\r
val SCE_PL_CHARACTER=7\r
val SCE_PL_PUNCTUATION=8\r
val SCE_PL_PREPROCESSOR=9\r
val SCE_PL_OPERATOR=10\r
val SCE_PL_IDENTIFIER=11\r
val SCE_PL_SCALAR=12\r
val SCE_PL_ARRAY=13\r
val SCE_PL_HASH=14\r
val SCE_PL_SYMBOLTABLE=15\r
val SCE_PL_VARIABLE_INDEXER=16\r
val SCE_PL_REGEX=17\r
val SCE_PL_REGSUBST=18\r
val SCE_PL_LONGQUOTE=19\r
val SCE_PL_BACKTICKS=20\r
val SCE_PL_DATASECTION=21\r
val SCE_PL_HERE_DELIM=22\r
val SCE_PL_HERE_Q=23\r
val SCE_PL_HERE_QQ=24\r
val SCE_PL_HERE_QX=25\r
val SCE_PL_STRING_Q=26\r
val SCE_PL_STRING_QQ=27\r
val SCE_PL_STRING_QX=28\r
val SCE_PL_STRING_QR=29\r
val SCE_PL_STRING_QW=30\r
val SCE_PL_POD_VERB=31\r
val SCE_PL_SUB_PROTOTYPE=40\r
val SCE_PL_FORMAT_IDENT=41\r
val SCE_PL_FORMAT=42\r
val SCE_PL_STRING_VAR=43\r
val SCE_PL_XLAT=44\r
val SCE_PL_REGEX_VAR=54\r
val SCE_PL_REGSUBST_VAR=55\r
val SCE_PL_BACKTICKS_VAR=57\r
val SCE_PL_HERE_QQ_VAR=61\r
val SCE_PL_HERE_QX_VAR=62\r
val SCE_PL_STRING_QQ_VAR=64\r
val SCE_PL_STRING_QX_VAR=65\r
val SCE_PL_STRING_QR_VAR=66\r
# Lexical states for SCLEX_RUBY\r
lex Ruby=SCLEX_RUBY SCE_RB_\r
val SCE_RB_DEFAULT=0\r
val SCE_RB_ERROR=1\r
val SCE_RB_COMMENTLINE=2\r
val SCE_RB_POD=3\r
val SCE_RB_NUMBER=4\r
val SCE_RB_WORD=5\r
val SCE_RB_STRING=6\r
val SCE_RB_CHARACTER=7\r
val SCE_RB_CLASSNAME=8\r
val SCE_RB_DEFNAME=9\r
val SCE_RB_OPERATOR=10\r
val SCE_RB_IDENTIFIER=11\r
val SCE_RB_REGEX=12\r
val SCE_RB_GLOBAL=13\r
val SCE_RB_SYMBOL=14\r
val SCE_RB_MODULE_NAME=15\r
val SCE_RB_INSTANCE_VAR=16\r
val SCE_RB_CLASS_VAR=17\r
val SCE_RB_BACKTICKS=18\r
val SCE_RB_DATASECTION=19\r
val SCE_RB_HERE_DELIM=20\r
val SCE_RB_HERE_Q=21\r
val SCE_RB_HERE_QQ=22\r
val SCE_RB_HERE_QX=23\r
val SCE_RB_STRING_Q=24\r
val SCE_RB_STRING_QQ=25\r
val SCE_RB_STRING_QX=26\r
val SCE_RB_STRING_QR=27\r
val SCE_RB_STRING_QW=28\r
val SCE_RB_WORD_DEMOTED=29\r
val SCE_RB_STDIN=30\r
val SCE_RB_STDOUT=31\r
val SCE_RB_STDERR=40\r
val SCE_RB_UPPER_BOUND=41\r
# Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC\r
lex VB=SCLEX_VB SCE_B_\r
lex VBScript=SCLEX_VBSCRIPT SCE_B_\r
lex PowerBasic=SCLEX_POWERBASIC SCE_B_\r
val SCE_B_DEFAULT=0\r
val SCE_B_COMMENT=1\r
val SCE_B_NUMBER=2\r
val SCE_B_KEYWORD=3\r
val SCE_B_STRING=4\r
val SCE_B_PREPROCESSOR=5\r
val SCE_B_OPERATOR=6\r
val SCE_B_IDENTIFIER=7\r
val SCE_B_DATE=8\r
val SCE_B_STRINGEOL=9\r
val SCE_B_KEYWORD2=10\r
val SCE_B_KEYWORD3=11\r
val SCE_B_KEYWORD4=12\r
val SCE_B_CONSTANT=13\r
val SCE_B_ASM=14\r
val SCE_B_LABEL=15\r
val SCE_B_ERROR=16\r
val SCE_B_HEXNUMBER=17\r
val SCE_B_BINNUMBER=18\r
val SCE_B_COMMENTBLOCK=19\r
val SCE_B_DOCLINE=20\r
val SCE_B_DOCBLOCK=21\r
val SCE_B_DOCKEYWORD=22\r
# Lexical states for SCLEX_PROPERTIES\r
lex Properties=SCLEX_PROPERTIES SCE_PROPS_\r
val SCE_PROPS_DEFAULT=0\r
val SCE_PROPS_COMMENT=1\r
val SCE_PROPS_SECTION=2\r
val SCE_PROPS_ASSIGNMENT=3\r
val SCE_PROPS_DEFVAL=4\r
val SCE_PROPS_KEY=5\r
# Lexical states for SCLEX_LATEX\r
lex LaTeX=SCLEX_LATEX SCE_L_\r
val SCE_L_DEFAULT=0\r
val SCE_L_COMMAND=1\r
val SCE_L_TAG=2\r
val SCE_L_MATH=3\r
val SCE_L_COMMENT=4\r
val SCE_L_TAG2=5\r
val SCE_L_MATH2=6\r
val SCE_L_COMMENT2=7\r
val SCE_L_VERBATIM=8\r
val SCE_L_SHORTCMD=9\r
val SCE_L_SPECIAL=10\r
val SCE_L_CMDOPT=11\r
val SCE_L_ERROR=12\r
# Lexical states for SCLEX_LUA\r
lex Lua=SCLEX_LUA SCE_LUA_\r
val SCE_LUA_DEFAULT=0\r
val SCE_LUA_COMMENT=1\r
val SCE_LUA_COMMENTLINE=2\r
val SCE_LUA_COMMENTDOC=3\r
val SCE_LUA_NUMBER=4\r
val SCE_LUA_WORD=5\r
val SCE_LUA_STRING=6\r
val SCE_LUA_CHARACTER=7\r
val SCE_LUA_LITERALSTRING=8\r
val SCE_LUA_PREPROCESSOR=9\r
val SCE_LUA_OPERATOR=10\r
val SCE_LUA_IDENTIFIER=11\r
val SCE_LUA_STRINGEOL=12\r
val SCE_LUA_WORD2=13\r
val SCE_LUA_WORD3=14\r
val SCE_LUA_WORD4=15\r
val SCE_LUA_WORD5=16\r
val SCE_LUA_WORD6=17\r
val SCE_LUA_WORD7=18\r
val SCE_LUA_WORD8=19\r
val SCE_LUA_LABEL=20\r
# Lexical states for SCLEX_ERRORLIST\r
lex ErrorList=SCLEX_ERRORLIST SCE_ERR_\r
val SCE_ERR_DEFAULT=0\r
val SCE_ERR_PYTHON=1\r
val SCE_ERR_GCC=2\r
val SCE_ERR_MS=3\r
val SCE_ERR_CMD=4\r
val SCE_ERR_BORLAND=5\r
val SCE_ERR_PERL=6\r
val SCE_ERR_NET=7\r
val SCE_ERR_LUA=8\r
val SCE_ERR_CTAG=9\r
val SCE_ERR_DIFF_CHANGED=10\r
val SCE_ERR_DIFF_ADDITION=11\r
val SCE_ERR_DIFF_DELETION=12\r
val SCE_ERR_DIFF_MESSAGE=13\r
val SCE_ERR_PHP=14\r
val SCE_ERR_ELF=15\r
val SCE_ERR_IFC=16\r
val SCE_ERR_IFORT=17\r
val SCE_ERR_ABSF=18\r
val SCE_ERR_TIDY=19\r
val SCE_ERR_JAVA_STACK=20\r
val SCE_ERR_VALUE=21\r
val SCE_ERR_GCC_INCLUDED_FROM=22\r
# Lexical states for SCLEX_BATCH\r
lex Batch=SCLEX_BATCH SCE_BAT_\r
val SCE_BAT_DEFAULT=0\r
val SCE_BAT_COMMENT=1\r
val SCE_BAT_WORD=2\r
val SCE_BAT_LABEL=3\r
val SCE_BAT_HIDE=4\r
val SCE_BAT_COMMAND=5\r
val SCE_BAT_IDENTIFIER=6\r
val SCE_BAT_OPERATOR=7\r
# Lexical states for SCLEX_TCMD\r
lex TCMD=SCLEX_TCMD SCE_TCMD_\r
val SCE_TCMD_DEFAULT=0\r
val SCE_TCMD_COMMENT=1\r
val SCE_TCMD_WORD=2\r
val SCE_TCMD_LABEL=3\r
val SCE_TCMD_HIDE=4\r
val SCE_TCMD_COMMAND=5\r
val SCE_TCMD_IDENTIFIER=6\r
val SCE_TCMD_OPERATOR=7\r
val SCE_TCMD_ENVIRONMENT=8\r
val SCE_TCMD_EXPANSION=9\r
val SCE_TCMD_CLABEL=10\r
# Lexical states for SCLEX_MAKEFILE\r
lex MakeFile=SCLEX_MAKEFILE SCE_MAKE_\r
val SCE_MAKE_DEFAULT=0\r
val SCE_MAKE_COMMENT=1\r
val SCE_MAKE_PREPROCESSOR=2\r
val SCE_MAKE_IDENTIFIER=3\r
val SCE_MAKE_OPERATOR=4\r
val SCE_MAKE_TARGET=5\r
val SCE_MAKE_IDEOL=9\r
# Lexical states for SCLEX_DIFF\r
lex Diff=SCLEX_DIFF SCE_DIFF_\r
val SCE_DIFF_DEFAULT=0\r
val SCE_DIFF_COMMENT=1\r
val SCE_DIFF_COMMAND=2\r
val SCE_DIFF_HEADER=3\r
val SCE_DIFF_POSITION=4\r
val SCE_DIFF_DELETED=5\r
val SCE_DIFF_ADDED=6\r
val SCE_DIFF_CHANGED=7\r
# Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)\r
lex Conf=SCLEX_CONF SCE_CONF_\r
val SCE_CONF_DEFAULT=0\r
val SCE_CONF_COMMENT=1\r
val SCE_CONF_NUMBER=2\r
val SCE_CONF_IDENTIFIER=3\r
val SCE_CONF_EXTENSION=4\r
val SCE_CONF_PARAMETER=5\r
val SCE_CONF_STRING=6\r
val SCE_CONF_OPERATOR=7\r
val SCE_CONF_IP=8\r
val SCE_CONF_DIRECTIVE=9\r
# Lexical states for SCLEX_AVE, Avenue\r
lex Avenue=SCLEX_AVE SCE_AVE_\r
val SCE_AVE_DEFAULT=0\r
val SCE_AVE_COMMENT=1\r
val SCE_AVE_NUMBER=2\r
val SCE_AVE_WORD=3\r
val SCE_AVE_STRING=6\r
val SCE_AVE_ENUM=7\r
val SCE_AVE_STRINGEOL=8\r
val SCE_AVE_IDENTIFIER=9\r
val SCE_AVE_OPERATOR=10\r
val SCE_AVE_WORD1=11\r
val SCE_AVE_WORD2=12\r
val SCE_AVE_WORD3=13\r
val SCE_AVE_WORD4=14\r
val SCE_AVE_WORD5=15\r
val SCE_AVE_WORD6=16\r
# Lexical states for SCLEX_ADA\r
lex Ada=SCLEX_ADA SCE_ADA_\r
val SCE_ADA_DEFAULT=0\r
val SCE_ADA_WORD=1\r
val SCE_ADA_IDENTIFIER=2\r
val SCE_ADA_NUMBER=3\r
val SCE_ADA_DELIMITER=4\r
val SCE_ADA_CHARACTER=5\r
val SCE_ADA_CHARACTEREOL=6\r
val SCE_ADA_STRING=7\r
val SCE_ADA_STRINGEOL=8\r
val SCE_ADA_LABEL=9\r
val SCE_ADA_COMMENTLINE=10\r
val SCE_ADA_ILLEGAL=11\r
# Lexical states for SCLEX_BAAN\r
lex Baan=SCLEX_BAAN SCE_BAAN_\r
val SCE_BAAN_DEFAULT=0\r
val SCE_BAAN_COMMENT=1\r
val SCE_BAAN_COMMENTDOC=2\r
val SCE_BAAN_NUMBER=3\r
val SCE_BAAN_WORD=4\r
val SCE_BAAN_STRING=5\r
val SCE_BAAN_PREPROCESSOR=6\r
val SCE_BAAN_OPERATOR=7\r
val SCE_BAAN_IDENTIFIER=8\r
val SCE_BAAN_STRINGEOL=9\r
val SCE_BAAN_WORD2=10\r
# Lexical states for SCLEX_LISP\r
lex Lisp=SCLEX_LISP SCE_LISP_\r
val SCE_LISP_DEFAULT=0\r
val SCE_LISP_COMMENT=1\r
val SCE_LISP_NUMBER=2\r
val SCE_LISP_KEYWORD=3\r
val SCE_LISP_KEYWORD_KW=4\r
val SCE_LISP_SYMBOL=5\r
val SCE_LISP_STRING=6\r
val SCE_LISP_STRINGEOL=8\r
val SCE_LISP_IDENTIFIER=9\r
val SCE_LISP_OPERATOR=10\r
val SCE_LISP_SPECIAL=11\r
val SCE_LISP_MULTI_COMMENT=12\r
# Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW\r
lex Eiffel=SCLEX_EIFFEL SCE_EIFFEL_\r
lex EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_\r
val SCE_EIFFEL_DEFAULT=0\r
val SCE_EIFFEL_COMMENTLINE=1\r
val SCE_EIFFEL_NUMBER=2\r
val SCE_EIFFEL_WORD=3\r
val SCE_EIFFEL_STRING=4\r
val SCE_EIFFEL_CHARACTER=5\r
val SCE_EIFFEL_OPERATOR=6\r
val SCE_EIFFEL_IDENTIFIER=7\r
val SCE_EIFFEL_STRINGEOL=8\r
# Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)\r
lex NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_\r
val SCE_NNCRONTAB_DEFAULT=0\r
val SCE_NNCRONTAB_COMMENT=1\r
val SCE_NNCRONTAB_TASK=2\r
val SCE_NNCRONTAB_SECTION=3\r
val SCE_NNCRONTAB_KEYWORD=4\r
val SCE_NNCRONTAB_MODIFIER=5\r
val SCE_NNCRONTAB_ASTERISK=6\r
val SCE_NNCRONTAB_NUMBER=7\r
val SCE_NNCRONTAB_STRING=8\r
val SCE_NNCRONTAB_ENVIRONMENT=9\r
val SCE_NNCRONTAB_IDENTIFIER=10\r
# Lexical states for SCLEX_FORTH (Forth Lexer)\r
lex Forth=SCLEX_FORTH SCE_FORTH_\r
val SCE_FORTH_DEFAULT=0\r
val SCE_FORTH_COMMENT=1\r
val SCE_FORTH_COMMENT_ML=2\r
val SCE_FORTH_IDENTIFIER=3\r
val SCE_FORTH_CONTROL=4\r
val SCE_FORTH_KEYWORD=5\r
val SCE_FORTH_DEFWORD=6\r
val SCE_FORTH_PREWORD1=7\r
val SCE_FORTH_PREWORD2=8\r
val SCE_FORTH_NUMBER=9\r
val SCE_FORTH_STRING=10\r
val SCE_FORTH_LOCALE=11\r
# Lexical states for SCLEX_MATLAB\r
lex MatLab=SCLEX_MATLAB SCE_MATLAB_\r
val SCE_MATLAB_DEFAULT=0\r
val SCE_MATLAB_COMMENT=1\r
val SCE_MATLAB_COMMAND=2\r
val SCE_MATLAB_NUMBER=3\r
val SCE_MATLAB_KEYWORD=4\r
# single quoted string\r
val SCE_MATLAB_STRING=5\r
val SCE_MATLAB_OPERATOR=6\r
val SCE_MATLAB_IDENTIFIER=7\r
val SCE_MATLAB_DOUBLEQUOTESTRING=8\r
# Lexical states for SCLEX_SCRIPTOL\r
lex Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_\r
val SCE_SCRIPTOL_DEFAULT=0\r
val SCE_SCRIPTOL_WHITE=1\r
val SCE_SCRIPTOL_COMMENTLINE=2\r
val SCE_SCRIPTOL_PERSISTENT=3\r
val SCE_SCRIPTOL_CSTYLE=4\r
val SCE_SCRIPTOL_COMMENTBLOCK=5\r
val SCE_SCRIPTOL_NUMBER=6\r
val SCE_SCRIPTOL_STRING=7\r
val SCE_SCRIPTOL_CHARACTER=8\r
val SCE_SCRIPTOL_STRINGEOL=9\r
val SCE_SCRIPTOL_KEYWORD=10\r
val SCE_SCRIPTOL_OPERATOR=11\r
val SCE_SCRIPTOL_IDENTIFIER=12\r
val SCE_SCRIPTOL_TRIPLE=13\r
val SCE_SCRIPTOL_CLASSNAME=14\r
val SCE_SCRIPTOL_PREPROCESSOR=15\r
# Lexical states for SCLEX_ASM, SCLEX_AS\r
lex Asm=SCLEX_ASM SCE_ASM_\r
lex As=SCLEX_AS SCE_ASM_\r
val SCE_ASM_DEFAULT=0\r
val SCE_ASM_COMMENT=1\r
val SCE_ASM_NUMBER=2\r
val SCE_ASM_STRING=3\r
val SCE_ASM_OPERATOR=4\r
val SCE_ASM_IDENTIFIER=5\r
val SCE_ASM_CPUINSTRUCTION=6\r
val SCE_ASM_MATHINSTRUCTION=7\r
val SCE_ASM_REGISTER=8\r
val SCE_ASM_DIRECTIVE=9\r
val SCE_ASM_DIRECTIVEOPERAND=10\r
val SCE_ASM_COMMENTBLOCK=11\r
val SCE_ASM_CHARACTER=12\r
val SCE_ASM_STRINGEOL=13\r
val SCE_ASM_EXTINSTRUCTION=14\r
val SCE_ASM_COMMENTDIRECTIVE=15\r
# Lexical states for SCLEX_FORTRAN\r
lex Fortran=SCLEX_FORTRAN SCE_F_\r
lex F77=SCLEX_F77 SCE_F_\r
val SCE_F_DEFAULT=0\r
val SCE_F_COMMENT=1\r
val SCE_F_NUMBER=2\r
val SCE_F_STRING1=3\r
val SCE_F_STRING2=4\r
val SCE_F_STRINGEOL=5\r
val SCE_F_OPERATOR=6\r
val SCE_F_IDENTIFIER=7\r
val SCE_F_WORD=8\r
val SCE_F_WORD2=9\r
val SCE_F_WORD3=10\r
val SCE_F_PREPROCESSOR=11\r
val SCE_F_OPERATOR2=12\r
val SCE_F_LABEL=13\r
val SCE_F_CONTINUATION=14\r
# Lexical states for SCLEX_CSS\r
lex CSS=SCLEX_CSS SCE_CSS_\r
val SCE_CSS_DEFAULT=0\r
val SCE_CSS_TAG=1\r
val SCE_CSS_CLASS=2\r
val SCE_CSS_PSEUDOCLASS=3\r
val SCE_CSS_UNKNOWN_PSEUDOCLASS=4\r
val SCE_CSS_OPERATOR=5\r
val SCE_CSS_IDENTIFIER=6\r
val SCE_CSS_UNKNOWN_IDENTIFIER=7\r
val SCE_CSS_VALUE=8\r
val SCE_CSS_COMMENT=9\r
val SCE_CSS_ID=10\r
val SCE_CSS_IMPORTANT=11\r
val SCE_CSS_DIRECTIVE=12\r
val SCE_CSS_DOUBLESTRING=13\r
val SCE_CSS_SINGLESTRING=14\r
val SCE_CSS_IDENTIFIER2=15\r
val SCE_CSS_ATTRIBUTE=16\r
val SCE_CSS_IDENTIFIER3=17\r
val SCE_CSS_PSEUDOELEMENT=18\r
val SCE_CSS_EXTENDED_IDENTIFIER=19\r
val SCE_CSS_EXTENDED_PSEUDOCLASS=20\r
val SCE_CSS_EXTENDED_PSEUDOELEMENT=21\r
val SCE_CSS_MEDIA=22\r
val SCE_CSS_VARIABLE=23\r
# Lexical states for SCLEX_POV\r
lex POV=SCLEX_POV SCE_POV_\r
val SCE_POV_DEFAULT=0\r
val SCE_POV_COMMENT=1\r
val SCE_POV_COMMENTLINE=2\r
val SCE_POV_NUMBER=3\r
val SCE_POV_OPERATOR=4\r
val SCE_POV_IDENTIFIER=5\r
val SCE_POV_STRING=6\r
val SCE_POV_STRINGEOL=7\r
val SCE_POV_DIRECTIVE=8\r
val SCE_POV_BADDIRECTIVE=9\r
val SCE_POV_WORD2=10\r
val SCE_POV_WORD3=11\r
val SCE_POV_WORD4=12\r
val SCE_POV_WORD5=13\r
val SCE_POV_WORD6=14\r
val SCE_POV_WORD7=15\r
val SCE_POV_WORD8=16\r
# Lexical states for SCLEX_LOUT\r
lex LOUT=SCLEX_LOUT SCE_LOUT_\r
val SCE_LOUT_DEFAULT=0\r
val SCE_LOUT_COMMENT=1\r
val SCE_LOUT_NUMBER=2\r
val SCE_LOUT_WORD=3\r
val SCE_LOUT_WORD2=4\r
val SCE_LOUT_WORD3=5\r
val SCE_LOUT_WORD4=6\r
val SCE_LOUT_STRING=7\r
val SCE_LOUT_OPERATOR=8\r
val SCE_LOUT_IDENTIFIER=9\r
val SCE_LOUT_STRINGEOL=10\r
# Lexical states for SCLEX_ESCRIPT\r
lex ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_\r
val SCE_ESCRIPT_DEFAULT=0\r
val SCE_ESCRIPT_COMMENT=1\r
val SCE_ESCRIPT_COMMENTLINE=2\r
val SCE_ESCRIPT_COMMENTDOC=3\r
val SCE_ESCRIPT_NUMBER=4\r
val SCE_ESCRIPT_WORD=5\r
val SCE_ESCRIPT_STRING=6\r
val SCE_ESCRIPT_OPERATOR=7\r
val SCE_ESCRIPT_IDENTIFIER=8\r
val SCE_ESCRIPT_BRACE=9\r
val SCE_ESCRIPT_WORD2=10\r
val SCE_ESCRIPT_WORD3=11\r
# Lexical states for SCLEX_PS\r
lex PS=SCLEX_PS SCE_PS_\r
val SCE_PS_DEFAULT=0\r
val SCE_PS_COMMENT=1\r
val SCE_PS_DSC_COMMENT=2\r
val SCE_PS_DSC_VALUE=3\r
val SCE_PS_NUMBER=4\r
val SCE_PS_NAME=5\r
val SCE_PS_KEYWORD=6\r
val SCE_PS_LITERAL=7\r
val SCE_PS_IMMEVAL=8\r
val SCE_PS_PAREN_ARRAY=9\r
val SCE_PS_PAREN_DICT=10\r
val SCE_PS_PAREN_PROC=11\r
val SCE_PS_TEXT=12\r
val SCE_PS_HEXSTRING=13\r
val SCE_PS_BASE85STRING=14\r
val SCE_PS_BADSTRINGCHAR=15\r
# Lexical states for SCLEX_NSIS\r
lex NSIS=SCLEX_NSIS SCE_NSIS_\r
val SCE_NSIS_DEFAULT=0\r
val SCE_NSIS_COMMENT=1\r
val SCE_NSIS_STRINGDQ=2\r
val SCE_NSIS_STRINGLQ=3\r
val SCE_NSIS_STRINGRQ=4\r
val SCE_NSIS_FUNCTION=5\r
val SCE_NSIS_VARIABLE=6\r
val SCE_NSIS_LABEL=7\r
val SCE_NSIS_USERDEFINED=8\r
val SCE_NSIS_SECTIONDEF=9\r
val SCE_NSIS_SUBSECTIONDEF=10\r
val SCE_NSIS_IFDEFINEDEF=11\r
val SCE_NSIS_MACRODEF=12\r
val SCE_NSIS_STRINGVAR=13\r
val SCE_NSIS_NUMBER=14\r
val SCE_NSIS_SECTIONGROUP=15\r
val SCE_NSIS_PAGEEX=16\r
val SCE_NSIS_FUNCTIONDEF=17\r
val SCE_NSIS_COMMENTBOX=18\r
# Lexical states for SCLEX_MMIXAL\r
lex MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_\r
val SCE_MMIXAL_LEADWS=0\r
val SCE_MMIXAL_COMMENT=1\r
val SCE_MMIXAL_LABEL=2\r
val SCE_MMIXAL_OPCODE=3\r
val SCE_MMIXAL_OPCODE_PRE=4\r
val SCE_MMIXAL_OPCODE_VALID=5\r
val SCE_MMIXAL_OPCODE_UNKNOWN=6\r
val SCE_MMIXAL_OPCODE_POST=7\r
val SCE_MMIXAL_OPERANDS=8\r
val SCE_MMIXAL_NUMBER=9\r
val SCE_MMIXAL_REF=10\r
val SCE_MMIXAL_CHAR=11\r
val SCE_MMIXAL_STRING=12\r
val SCE_MMIXAL_REGISTER=13\r
val SCE_MMIXAL_HEX=14\r
val SCE_MMIXAL_OPERATOR=15\r
val SCE_MMIXAL_SYMBOL=16\r
val SCE_MMIXAL_INCLUDE=17\r
# Lexical states for SCLEX_CLW\r
lex Clarion=SCLEX_CLW SCE_CLW_\r
val SCE_CLW_DEFAULT=0\r
val SCE_CLW_LABEL=1\r
val SCE_CLW_COMMENT=2\r
val SCE_CLW_STRING=3\r
val SCE_CLW_USER_IDENTIFIER=4\r
val SCE_CLW_INTEGER_CONSTANT=5\r
val SCE_CLW_REAL_CONSTANT=6\r
val SCE_CLW_PICTURE_STRING=7\r
val SCE_CLW_KEYWORD=8\r
val SCE_CLW_COMPILER_DIRECTIVE=9\r
val SCE_CLW_RUNTIME_EXPRESSIONS=10\r
val SCE_CLW_BUILTIN_PROCEDURES_FUNCTION=11\r
val SCE_CLW_STRUCTURE_DATA_TYPE=12\r
val SCE_CLW_ATTRIBUTE=13\r
val SCE_CLW_STANDARD_EQUATE=14\r
val SCE_CLW_ERROR=15\r
val SCE_CLW_DEPRECATED=16\r
# Lexical states for SCLEX_LOT\r
lex LOT=SCLEX_LOT SCE_LOT_\r
val SCE_LOT_DEFAULT=0\r
val SCE_LOT_HEADER=1\r
val SCE_LOT_BREAK=2\r
val SCE_LOT_SET=3\r
val SCE_LOT_PASS=4\r
val SCE_LOT_FAIL=5\r
val SCE_LOT_ABORT=6\r
# Lexical states for SCLEX_YAML\r
lex YAML=SCLEX_YAML SCE_YAML_\r
val SCE_YAML_DEFAULT=0\r
val SCE_YAML_COMMENT=1\r
val SCE_YAML_IDENTIFIER=2\r
val SCE_YAML_KEYWORD=3\r
val SCE_YAML_NUMBER=4\r
val SCE_YAML_REFERENCE=5\r
val SCE_YAML_DOCUMENT=6\r
val SCE_YAML_TEXT=7\r
val SCE_YAML_ERROR=8\r
val SCE_YAML_OPERATOR=9\r
# Lexical states for SCLEX_TEX\r
lex TeX=SCLEX_TEX SCE_TEX_\r
val SCE_TEX_DEFAULT=0\r
val SCE_TEX_SPECIAL=1\r
val SCE_TEX_GROUP=2\r
val SCE_TEX_SYMBOL=3\r
val SCE_TEX_COMMAND=4\r
val SCE_TEX_TEXT=5\r
lex Metapost=SCLEX_METAPOST SCE_METAPOST_\r
val SCE_METAPOST_DEFAULT=0\r
val SCE_METAPOST_SPECIAL=1\r
val SCE_METAPOST_GROUP=2\r
val SCE_METAPOST_SYMBOL=3\r
val SCE_METAPOST_COMMAND=4\r
val SCE_METAPOST_TEXT=5\r
val SCE_METAPOST_EXTRA=6\r
# Lexical states for SCLEX_ERLANG\r
lex Erlang=SCLEX_ERLANG SCE_ERLANG_\r
val SCE_ERLANG_DEFAULT=0\r
val SCE_ERLANG_COMMENT=1\r
val SCE_ERLANG_VARIABLE=2\r
val SCE_ERLANG_NUMBER=3\r
val SCE_ERLANG_KEYWORD=4\r
val SCE_ERLANG_STRING=5\r
val SCE_ERLANG_OPERATOR=6\r
val SCE_ERLANG_ATOM=7\r
val SCE_ERLANG_FUNCTION_NAME=8\r
val SCE_ERLANG_CHARACTER=9\r
val SCE_ERLANG_MACRO=10\r
val SCE_ERLANG_RECORD=11\r
val SCE_ERLANG_PREPROC=12\r
val SCE_ERLANG_NODE_NAME=13\r
val SCE_ERLANG_COMMENT_FUNCTION=14\r
val SCE_ERLANG_COMMENT_MODULE=15\r
val SCE_ERLANG_COMMENT_DOC=16\r
val SCE_ERLANG_COMMENT_DOC_MACRO=17\r
val SCE_ERLANG_ATOM_QUOTED=18\r
val SCE_ERLANG_MACRO_QUOTED=19\r
val SCE_ERLANG_RECORD_QUOTED=20\r
val SCE_ERLANG_NODE_NAME_QUOTED=21\r
val SCE_ERLANG_BIFS=22\r
val SCE_ERLANG_MODULES=23\r
val SCE_ERLANG_MODULES_ATT=24\r
val SCE_ERLANG_UNKNOWN=31\r
# Lexical states for SCLEX_OCTAVE are identical to MatLab\r
lex Octave=SCLEX_OCTAVE SCE_MATLAB_\r
# Lexical states for SCLEX_MSSQL\r
lex MSSQL=SCLEX_MSSQL SCE_MSSQL_\r
val SCE_MSSQL_DEFAULT=0\r
val SCE_MSSQL_COMMENT=1\r
val SCE_MSSQL_LINE_COMMENT=2\r
val SCE_MSSQL_NUMBER=3\r
val SCE_MSSQL_STRING=4\r
val SCE_MSSQL_OPERATOR=5\r
val SCE_MSSQL_IDENTIFIER=6\r
val SCE_MSSQL_VARIABLE=7\r
val SCE_MSSQL_COLUMN_NAME=8\r
val SCE_MSSQL_STATEMENT=9\r
val SCE_MSSQL_DATATYPE=10\r
val SCE_MSSQL_SYSTABLE=11\r
val SCE_MSSQL_GLOBAL_VARIABLE=12\r
val SCE_MSSQL_FUNCTION=13\r
val SCE_MSSQL_STORED_PROCEDURE=14\r
val SCE_MSSQL_DEFAULT_PREF_DATATYPE=15\r
val SCE_MSSQL_COLUMN_NAME_2=16\r
# Lexical states for SCLEX_VERILOG\r
lex Verilog=SCLEX_VERILOG SCE_V_\r
val SCE_V_DEFAULT=0\r
val SCE_V_COMMENT=1\r
val SCE_V_COMMENTLINE=2\r
val SCE_V_COMMENTLINEBANG=3\r
val SCE_V_NUMBER=4\r
val SCE_V_WORD=5\r
val SCE_V_STRING=6\r
val SCE_V_WORD2=7\r
val SCE_V_WORD3=8\r
val SCE_V_PREPROCESSOR=9\r
val SCE_V_OPERATOR=10\r
val SCE_V_IDENTIFIER=11\r
val SCE_V_STRINGEOL=12\r
val SCE_V_USER=19\r
val SCE_V_COMMENT_WORD=20\r
val SCE_V_INPUT=21\r
val SCE_V_OUTPUT=22\r
val SCE_V_INOUT=23\r
val SCE_V_PORT_CONNECT=24\r
# Lexical states for SCLEX_KIX\r
lex Kix=SCLEX_KIX SCE_KIX_\r
val SCE_KIX_DEFAULT=0\r
val SCE_KIX_COMMENT=1\r
val SCE_KIX_STRING1=2\r
val SCE_KIX_STRING2=3\r
val SCE_KIX_NUMBER=4\r
val SCE_KIX_VAR=5\r
val SCE_KIX_MACRO=6\r
val SCE_KIX_KEYWORD=7\r
val SCE_KIX_FUNCTIONS=8\r
val SCE_KIX_OPERATOR=9\r
val SCE_KIX_COMMENTSTREAM=10\r
val SCE_KIX_IDENTIFIER=31\r
# Lexical states for SCLEX_GUI4CLI\r
lex Gui4Cli=SCLEX_GUI4CLI SCE_GC_\r
val SCE_GC_DEFAULT=0\r
val SCE_GC_COMMENTLINE=1\r
val SCE_GC_COMMENTBLOCK=2\r
val SCE_GC_GLOBAL=3\r
val SCE_GC_EVENT=4\r
val SCE_GC_ATTRIBUTE=5\r
val SCE_GC_CONTROL=6\r
val SCE_GC_COMMAND=7\r
val SCE_GC_STRING=8\r
val SCE_GC_OPERATOR=9\r
# Lexical states for SCLEX_SPECMAN\r
lex Specman=SCLEX_SPECMAN SCE_SN_\r
val SCE_SN_DEFAULT=0\r
val SCE_SN_CODE=1\r
val SCE_SN_COMMENTLINE=2\r
val SCE_SN_COMMENTLINEBANG=3\r
val SCE_SN_NUMBER=4\r
val SCE_SN_WORD=5\r
val SCE_SN_STRING=6\r
val SCE_SN_WORD2=7\r
val SCE_SN_WORD3=8\r
val SCE_SN_PREPROCESSOR=9\r
val SCE_SN_OPERATOR=10\r
val SCE_SN_IDENTIFIER=11\r
val SCE_SN_STRINGEOL=12\r
val SCE_SN_REGEXTAG=13\r
val SCE_SN_SIGNAL=14\r
val SCE_SN_USER=19\r
# Lexical states for SCLEX_AU3\r
lex Au3=SCLEX_AU3 SCE_AU3_\r
val SCE_AU3_DEFAULT=0\r
val SCE_AU3_COMMENT=1\r
val SCE_AU3_COMMENTBLOCK=2\r
val SCE_AU3_NUMBER=3\r
val SCE_AU3_FUNCTION=4\r
val SCE_AU3_KEYWORD=5\r
val SCE_AU3_MACRO=6\r
val SCE_AU3_STRING=7\r
val SCE_AU3_OPERATOR=8\r
val SCE_AU3_VARIABLE=9\r
val SCE_AU3_SENT=10\r
val SCE_AU3_PREPROCESSOR=11\r
val SCE_AU3_SPECIAL=12\r
val SCE_AU3_EXPAND=13\r
val SCE_AU3_COMOBJ=14\r
val SCE_AU3_UDF=15\r
# Lexical states for SCLEX_APDL\r
lex APDL=SCLEX_APDL SCE_APDL_\r
val SCE_APDL_DEFAULT=0\r
val SCE_APDL_COMMENT=1\r
val SCE_APDL_COMMENTBLOCK=2\r
val SCE_APDL_NUMBER=3\r
val SCE_APDL_STRING=4\r
val SCE_APDL_OPERATOR=5\r
val SCE_APDL_WORD=6\r
val SCE_APDL_PROCESSOR=7\r
val SCE_APDL_COMMAND=8\r
val SCE_APDL_SLASHCOMMAND=9\r
val SCE_APDL_STARCOMMAND=10\r
val SCE_APDL_ARGUMENT=11\r
val SCE_APDL_FUNCTION=12\r
# Lexical states for SCLEX_BASH\r
lex Bash=SCLEX_BASH SCE_SH_\r
val SCE_SH_DEFAULT=0\r
val SCE_SH_ERROR=1\r
val SCE_SH_COMMENTLINE=2\r
val SCE_SH_NUMBER=3\r
val SCE_SH_WORD=4\r
val SCE_SH_STRING=5\r
val SCE_SH_CHARACTER=6\r
val SCE_SH_OPERATOR=7\r
val SCE_SH_IDENTIFIER=8\r
val SCE_SH_SCALAR=9\r
val SCE_SH_PARAM=10\r
val SCE_SH_BACKTICKS=11\r
val SCE_SH_HERE_DELIM=12\r
val SCE_SH_HERE_Q=13\r
# Lexical states for SCLEX_ASN1\r
lex Asn1=SCLEX_ASN1 SCE_ASN1_\r
val SCE_ASN1_DEFAULT=0\r
val SCE_ASN1_COMMENT=1\r
val SCE_ASN1_IDENTIFIER=2\r
val SCE_ASN1_STRING=3\r
val SCE_ASN1_OID=4\r
val SCE_ASN1_SCALAR=5\r
val SCE_ASN1_KEYWORD=6\r
val SCE_ASN1_ATTRIBUTE=7\r
val SCE_ASN1_DESCRIPTOR=8\r
val SCE_ASN1_TYPE=9\r
val SCE_ASN1_OPERATOR=10\r
# Lexical states for SCLEX_VHDL\r
lex VHDL=SCLEX_VHDL SCE_VHDL_\r
val SCE_VHDL_DEFAULT=0\r
val SCE_VHDL_COMMENT=1\r
val SCE_VHDL_COMMENTLINEBANG=2\r
val SCE_VHDL_NUMBER=3\r
val SCE_VHDL_STRING=4\r
val SCE_VHDL_OPERATOR=5\r
val SCE_VHDL_IDENTIFIER=6\r
val SCE_VHDL_STRINGEOL=7\r
val SCE_VHDL_KEYWORD=8\r
val SCE_VHDL_STDOPERATOR=9\r
val SCE_VHDL_ATTRIBUTE=10\r
val SCE_VHDL_STDFUNCTION=11\r
val SCE_VHDL_STDPACKAGE=12\r
val SCE_VHDL_STDTYPE=13\r
val SCE_VHDL_USERWORD=14\r
val SCE_VHDL_BLOCK_COMMENT=15\r
# Lexical states for SCLEX_CAML\r
lex Caml=SCLEX_CAML SCE_CAML_\r
val SCE_CAML_DEFAULT=0\r
val SCE_CAML_IDENTIFIER=1\r
val SCE_CAML_TAGNAME=2\r
val SCE_CAML_KEYWORD=3\r
val SCE_CAML_KEYWORD2=4\r
val SCE_CAML_KEYWORD3=5\r
val SCE_CAML_LINENUM=6\r
val SCE_CAML_OPERATOR=7\r
val SCE_CAML_NUMBER=8\r
val SCE_CAML_CHAR=9\r
val SCE_CAML_WHITE=10\r
val SCE_CAML_STRING=11\r
val SCE_CAML_COMMENT=12\r
val SCE_CAML_COMMENT1=13\r
val SCE_CAML_COMMENT2=14\r
val SCE_CAML_COMMENT3=15\r
# Lexical states for SCLEX_HASKELL\r
lex Haskell=SCLEX_HASKELL SCE_HA_\r
val SCE_HA_DEFAULT=0\r
val SCE_HA_IDENTIFIER=1\r
val SCE_HA_KEYWORD=2\r
val SCE_HA_NUMBER=3\r
val SCE_HA_STRING=4\r
val SCE_HA_CHARACTER=5\r
val SCE_HA_CLASS=6\r
val SCE_HA_MODULE=7\r
val SCE_HA_CAPITAL=8\r
val SCE_HA_DATA=9\r
val SCE_HA_IMPORT=10\r
val SCE_HA_OPERATOR=11\r
val SCE_HA_INSTANCE=12\r
val SCE_HA_COMMENTLINE=13\r
val SCE_HA_COMMENTBLOCK=14\r
val SCE_HA_COMMENTBLOCK2=15\r
val SCE_HA_COMMENTBLOCK3=16\r
val SCE_HA_PRAGMA=17\r
val SCE_HA_PREPROCESSOR=18\r
val SCE_HA_STRINGEOL=19\r
val SCE_HA_RESERVED_OPERATOR=20\r
val SCE_HA_LITERATE_COMMENT=21\r
val SCE_HA_LITERATE_CODEDELIM=22\r
# Lexical states of SCLEX_TADS3\r
lex TADS3=SCLEX_TADS3 SCE_T3_\r
val SCE_T3_DEFAULT=0\r
val SCE_T3_X_DEFAULT=1\r
val SCE_T3_PREPROCESSOR=2\r
val SCE_T3_BLOCK_COMMENT=3\r
val SCE_T3_LINE_COMMENT=4\r
val SCE_T3_OPERATOR=5\r
val SCE_T3_KEYWORD=6\r
val SCE_T3_NUMBER=7\r
val SCE_T3_IDENTIFIER=8\r
val SCE_T3_S_STRING=9\r
val SCE_T3_D_STRING=10\r
val SCE_T3_X_STRING=11\r
val SCE_T3_LIB_DIRECTIVE=12\r
val SCE_T3_MSG_PARAM=13\r
val SCE_T3_HTML_TAG=14\r
val SCE_T3_HTML_DEFAULT=15\r
val SCE_T3_HTML_STRING=16\r
val SCE_T3_USER1=17\r
val SCE_T3_USER2=18\r
val SCE_T3_USER3=19\r
val SCE_T3_BRACE=20\r
# Lexical states for SCLEX_REBOL\r
lex Rebol=SCLEX_REBOL SCE_REBOL_\r
val SCE_REBOL_DEFAULT=0\r
val SCE_REBOL_COMMENTLINE=1\r
val SCE_REBOL_COMMENTBLOCK=2\r
val SCE_REBOL_PREFACE=3\r
val SCE_REBOL_OPERATOR=4\r
val SCE_REBOL_CHARACTER=5\r
val SCE_REBOL_QUOTEDSTRING=6\r
val SCE_REBOL_BRACEDSTRING=7\r
val SCE_REBOL_NUMBER=8\r
val SCE_REBOL_PAIR=9\r
val SCE_REBOL_TUPLE=10\r
val SCE_REBOL_BINARY=11\r
val SCE_REBOL_MONEY=12\r
val SCE_REBOL_ISSUE=13\r
val SCE_REBOL_TAG=14\r
val SCE_REBOL_FILE=15\r
val SCE_REBOL_EMAIL=16\r
val SCE_REBOL_URL=17\r
val SCE_REBOL_DATE=18\r
val SCE_REBOL_TIME=19\r
val SCE_REBOL_IDENTIFIER=20\r
val SCE_REBOL_WORD=21\r
val SCE_REBOL_WORD2=22\r
val SCE_REBOL_WORD3=23\r
val SCE_REBOL_WORD4=24\r
val SCE_REBOL_WORD5=25\r
val SCE_REBOL_WORD6=26\r
val SCE_REBOL_WORD7=27\r
val SCE_REBOL_WORD8=28\r
# Lexical states for SCLEX_SQL\r
lex SQL=SCLEX_SQL SCE_SQL_\r
val SCE_SQL_DEFAULT=0\r
val SCE_SQL_COMMENT=1\r
val SCE_SQL_COMMENTLINE=2\r
val SCE_SQL_COMMENTDOC=3\r
val SCE_SQL_NUMBER=4\r
val SCE_SQL_WORD=5\r
val SCE_SQL_STRING=6\r
val SCE_SQL_CHARACTER=7\r
val SCE_SQL_SQLPLUS=8\r
val SCE_SQL_SQLPLUS_PROMPT=9\r
val SCE_SQL_OPERATOR=10\r
val SCE_SQL_IDENTIFIER=11\r
val SCE_SQL_SQLPLUS_COMMENT=13\r
val SCE_SQL_COMMENTLINEDOC=15\r
val SCE_SQL_WORD2=16\r
val SCE_SQL_COMMENTDOCKEYWORD=17\r
val SCE_SQL_COMMENTDOCKEYWORDERROR=18\r
val SCE_SQL_USER1=19\r
val SCE_SQL_USER2=20\r
val SCE_SQL_USER3=21\r
val SCE_SQL_USER4=22\r
val SCE_SQL_QUOTEDIDENTIFIER=23\r
val SCE_SQL_QOPERATOR=24\r
# Lexical states for SCLEX_SMALLTALK\r
lex Smalltalk=SCLEX_SMALLTALK SCE_ST_\r
val SCE_ST_DEFAULT=0\r
val SCE_ST_STRING=1\r
val SCE_ST_NUMBER=2\r
val SCE_ST_COMMENT=3\r
val SCE_ST_SYMBOL=4\r
val SCE_ST_BINARY=5\r
val SCE_ST_BOOL=6\r
val SCE_ST_SELF=7\r
val SCE_ST_SUPER=8\r
val SCE_ST_NIL=9\r
val SCE_ST_GLOBAL=10\r
val SCE_ST_RETURN=11\r
val SCE_ST_SPECIAL=12\r
val SCE_ST_KWSEND=13\r
val SCE_ST_ASSIGN=14\r
val SCE_ST_CHARACTER=15\r
val SCE_ST_SPEC_SEL=16\r
# Lexical states for SCLEX_FLAGSHIP (clipper)\r
lex FlagShip=SCLEX_FLAGSHIP SCE_FS_\r
val SCE_FS_DEFAULT=0\r
val SCE_FS_COMMENT=1\r
val SCE_FS_COMMENTLINE=2\r
val SCE_FS_COMMENTDOC=3\r
val SCE_FS_COMMENTLINEDOC=4\r
val SCE_FS_COMMENTDOCKEYWORD=5\r
val SCE_FS_COMMENTDOCKEYWORDERROR=6\r
val SCE_FS_KEYWORD=7\r
val SCE_FS_KEYWORD2=8\r
val SCE_FS_KEYWORD3=9\r
val SCE_FS_KEYWORD4=10\r
val SCE_FS_NUMBER=11\r
val SCE_FS_STRING=12\r
val SCE_FS_PREPROCESSOR=13\r
val SCE_FS_OPERATOR=14\r
val SCE_FS_IDENTIFIER=15\r
val SCE_FS_DATE=16\r
val SCE_FS_STRINGEOL=17\r
val SCE_FS_CONSTANT=18\r
val SCE_FS_WORDOPERATOR=19\r
val SCE_FS_DISABLEDCODE=20\r
val SCE_FS_DEFAULT_C=21\r
val SCE_FS_COMMENTDOC_C=22\r
val SCE_FS_COMMENTLINEDOC_C=23\r
val SCE_FS_KEYWORD_C=24\r
val SCE_FS_KEYWORD2_C=25\r
val SCE_FS_NUMBER_C=26\r
val SCE_FS_STRING_C=27\r
val SCE_FS_PREPROCESSOR_C=28\r
val SCE_FS_OPERATOR_C=29\r
val SCE_FS_IDENTIFIER_C=30\r
val SCE_FS_STRINGEOL_C=31\r
# Lexical states for SCLEX_CSOUND\r
lex Csound=SCLEX_CSOUND SCE_CSOUND_\r
val SCE_CSOUND_DEFAULT=0\r
val SCE_CSOUND_COMMENT=1\r
val SCE_CSOUND_NUMBER=2\r
val SCE_CSOUND_OPERATOR=3\r
val SCE_CSOUND_INSTR=4\r
val SCE_CSOUND_IDENTIFIER=5\r
val SCE_CSOUND_OPCODE=6\r
val SCE_CSOUND_HEADERSTMT=7\r
val SCE_CSOUND_USERKEYWORD=8\r
val SCE_CSOUND_COMMENTBLOCK=9\r
val SCE_CSOUND_PARAM=10\r
val SCE_CSOUND_ARATE_VAR=11\r
val SCE_CSOUND_KRATE_VAR=12\r
val SCE_CSOUND_IRATE_VAR=13\r
val SCE_CSOUND_GLOBAL_VAR=14\r
val SCE_CSOUND_STRINGEOL=15\r
# Lexical states for SCLEX_INNOSETUP\r
lex Inno=SCLEX_INNOSETUP SCE_INNO_\r
val SCE_INNO_DEFAULT=0\r
val SCE_INNO_COMMENT=1\r
val SCE_INNO_KEYWORD=2\r
val SCE_INNO_PARAMETER=3\r
val SCE_INNO_SECTION=4\r
val SCE_INNO_PREPROC=5\r
val SCE_INNO_INLINE_EXPANSION=6\r
val SCE_INNO_COMMENT_PASCAL=7\r
val SCE_INNO_KEYWORD_PASCAL=8\r
val SCE_INNO_KEYWORD_USER=9\r
val SCE_INNO_STRING_DOUBLE=10\r
val SCE_INNO_STRING_SINGLE=11\r
val SCE_INNO_IDENTIFIER=12\r
# Lexical states for SCLEX_OPAL\r
lex Opal=SCLEX_OPAL SCE_OPAL_\r
val SCE_OPAL_SPACE=0\r
val SCE_OPAL_COMMENT_BLOCK=1\r
val SCE_OPAL_COMMENT_LINE=2\r
val SCE_OPAL_INTEGER=3\r
val SCE_OPAL_KEYWORD=4\r
val SCE_OPAL_SORT=5\r
val SCE_OPAL_STRING=6\r
val SCE_OPAL_PAR=7\r
val SCE_OPAL_BOOL_CONST=8\r
val SCE_OPAL_DEFAULT=32\r
# Lexical states for SCLEX_SPICE\r
lex Spice=SCLEX_SPICE SCE_SPICE_\r
val SCE_SPICE_DEFAULT=0\r
val SCE_SPICE_IDENTIFIER=1\r
val SCE_SPICE_KEYWORD=2\r
val SCE_SPICE_KEYWORD2=3\r
val SCE_SPICE_KEYWORD3=4\r
val SCE_SPICE_NUMBER=5\r
val SCE_SPICE_DELIMITER=6\r
val SCE_SPICE_VALUE=7\r
val SCE_SPICE_COMMENTLINE=8\r
# Lexical states for SCLEX_CMAKE\r
lex CMAKE=SCLEX_CMAKE SCE_CMAKE_\r
val SCE_CMAKE_DEFAULT=0\r
val SCE_CMAKE_COMMENT=1\r
val SCE_CMAKE_STRINGDQ=2\r
val SCE_CMAKE_STRINGLQ=3\r
val SCE_CMAKE_STRINGRQ=4\r
val SCE_CMAKE_COMMANDS=5\r
val SCE_CMAKE_PARAMETERS=6\r
val SCE_CMAKE_VARIABLE=7\r
val SCE_CMAKE_USERDEFINED=8\r
val SCE_CMAKE_WHILEDEF=9\r
val SCE_CMAKE_FOREACHDEF=10\r
val SCE_CMAKE_IFDEFINEDEF=11\r
val SCE_CMAKE_MACRODEF=12\r
val SCE_CMAKE_STRINGVAR=13\r
val SCE_CMAKE_NUMBER=14\r
# Lexical states for SCLEX_GAP\r
lex Gap=SCLEX_GAP SCE_GAP_\r
val SCE_GAP_DEFAULT=0\r
val SCE_GAP_IDENTIFIER=1\r
val SCE_GAP_KEYWORD=2\r
val SCE_GAP_KEYWORD2=3\r
val SCE_GAP_KEYWORD3=4\r
val SCE_GAP_KEYWORD4=5\r
val SCE_GAP_STRING=6\r
val SCE_GAP_CHAR=7\r
val SCE_GAP_OPERATOR=8\r
val SCE_GAP_COMMENT=9\r
val SCE_GAP_NUMBER=10\r
val SCE_GAP_STRINGEOL=11\r
# Lexical state for SCLEX_PLM\r
lex PLM=SCLEX_PLM SCE_PLM_\r
val SCE_PLM_DEFAULT=0\r
val SCE_PLM_COMMENT=1\r
val SCE_PLM_STRING=2\r
val SCE_PLM_NUMBER=3\r
val SCE_PLM_IDENTIFIER=4\r
val SCE_PLM_OPERATOR=5\r
val SCE_PLM_CONTROL=6\r
val SCE_PLM_KEYWORD=7\r
# Lexical state for SCLEX_PROGRESS\r
lex Progress=SCLEX_PROGRESS SCE_4GL_\r
val SCE_4GL_DEFAULT=0\r
val SCE_4GL_NUMBER=1\r
val SCE_4GL_WORD=2\r
val SCE_4GL_STRING=3\r
val SCE_4GL_CHARACTER=4\r
val SCE_4GL_PREPROCESSOR=5\r
val SCE_4GL_OPERATOR=6\r
val SCE_4GL_IDENTIFIER=7\r
val SCE_4GL_BLOCK=8\r
val SCE_4GL_END=9\r
val SCE_4GL_COMMENT1=10\r
val SCE_4GL_COMMENT2=11\r
val SCE_4GL_COMMENT3=12\r
val SCE_4GL_COMMENT4=13\r
val SCE_4GL_COMMENT5=14\r
val SCE_4GL_COMMENT6=15\r
val SCE_4GL_DEFAULT_=16\r
val SCE_4GL_NUMBER_=17\r
val SCE_4GL_WORD_=18\r
val SCE_4GL_STRING_=19\r
val SCE_4GL_CHARACTER_=20\r
val SCE_4GL_PREPROCESSOR_=21\r
val SCE_4GL_OPERATOR_=22\r
val SCE_4GL_IDENTIFIER_=23\r
val SCE_4GL_BLOCK_=24\r
val SCE_4GL_END_=25\r
val SCE_4GL_COMMENT1_=26\r
val SCE_4GL_COMMENT2_=27\r
val SCE_4GL_COMMENT3_=28\r
val SCE_4GL_COMMENT4_=29\r
val SCE_4GL_COMMENT5_=30\r
val SCE_4GL_COMMENT6_=31\r
# Lexical states for SCLEX_ABAQUS\r
lex ABAQUS=SCLEX_ABAQUS SCE_ABAQUS_\r
val SCE_ABAQUS_DEFAULT=0\r
val SCE_ABAQUS_COMMENT=1\r
val SCE_ABAQUS_COMMENTBLOCK=2\r
val SCE_ABAQUS_NUMBER=3\r
val SCE_ABAQUS_STRING=4\r
val SCE_ABAQUS_OPERATOR=5\r
val SCE_ABAQUS_WORD=6\r
val SCE_ABAQUS_PROCESSOR=7\r
val SCE_ABAQUS_COMMAND=8\r
val SCE_ABAQUS_SLASHCOMMAND=9\r
val SCE_ABAQUS_STARCOMMAND=10\r
val SCE_ABAQUS_ARGUMENT=11\r
val SCE_ABAQUS_FUNCTION=12\r
# Lexical states for SCLEX_ASYMPTOTE\r
lex Asymptote=SCLEX_ASYMPTOTE SCE_ASY_\r
val SCE_ASY_DEFAULT=0\r
val SCE_ASY_COMMENT=1\r
val SCE_ASY_COMMENTLINE=2\r
val SCE_ASY_NUMBER=3\r
val SCE_ASY_WORD=4\r
val SCE_ASY_STRING=5\r
val SCE_ASY_CHARACTER=6\r
val SCE_ASY_OPERATOR=7\r
val SCE_ASY_IDENTIFIER=8\r
val SCE_ASY_STRINGEOL=9\r
val SCE_ASY_COMMENTLINEDOC=10\r
val SCE_ASY_WORD2=11\r
# Lexical states for SCLEX_R\r
lex R=SCLEX_R SCE_R_\r
val SCE_R_DEFAULT=0\r
val SCE_R_COMMENT=1\r
val SCE_R_KWORD=2\r
val SCE_R_BASEKWORD=3\r
val SCE_R_OTHERKWORD=4\r
val SCE_R_NUMBER=5\r
val SCE_R_STRING=6\r
val SCE_R_STRING2=7\r
val SCE_R_OPERATOR=8\r
val SCE_R_IDENTIFIER=9\r
val SCE_R_INFIX=10\r
val SCE_R_INFIXEOL=11\r
# Lexical state for SCLEX_MAGIK\r
lex MagikSF=SCLEX_MAGIK SCE_MAGIK_\r
val SCE_MAGIK_DEFAULT=0\r
val SCE_MAGIK_COMMENT=1\r
val SCE_MAGIK_HYPER_COMMENT=16\r
val SCE_MAGIK_STRING=2\r
val SCE_MAGIK_CHARACTER=3\r
val SCE_MAGIK_NUMBER=4\r
val SCE_MAGIK_IDENTIFIER=5\r
val SCE_MAGIK_OPERATOR=6\r
val SCE_MAGIK_FLOW=7\r
val SCE_MAGIK_CONTAINER=8\r
val SCE_MAGIK_BRACKET_BLOCK=9\r
val SCE_MAGIK_BRACE_BLOCK=10\r
val SCE_MAGIK_SQBRACKET_BLOCK=11\r
val SCE_MAGIK_UNKNOWN_KEYWORD=12\r
val SCE_MAGIK_KEYWORD=13\r
val SCE_MAGIK_PRAGMA=14\r
val SCE_MAGIK_SYMBOL=15\r
# Lexical state for SCLEX_POWERSHELL\r
lex PowerShell=SCLEX_POWERSHELL SCE_POWERSHELL_\r
val SCE_POWERSHELL_DEFAULT=0\r
val SCE_POWERSHELL_COMMENT=1\r
val SCE_POWERSHELL_STRING=2\r
val SCE_POWERSHELL_CHARACTER=3\r
val SCE_POWERSHELL_NUMBER=4\r
val SCE_POWERSHELL_VARIABLE=5\r
val SCE_POWERSHELL_OPERATOR=6\r
val SCE_POWERSHELL_IDENTIFIER=7\r
val SCE_POWERSHELL_KEYWORD=8\r
val SCE_POWERSHELL_CMDLET=9\r
val SCE_POWERSHELL_ALIAS=10\r
val SCE_POWERSHELL_FUNCTION=11\r
val SCE_POWERSHELL_USER1=12\r
val SCE_POWERSHELL_COMMENTSTREAM=13\r
val SCE_POWERSHELL_HERE_STRING=14\r
val SCE_POWERSHELL_HERE_CHARACTER=15\r
val SCE_POWERSHELL_COMMENTDOCKEYWORD=16\r
# Lexical state for SCLEX_MYSQL\r
lex MySQL=SCLEX_MYSQL SCE_MYSQL_\r
val SCE_MYSQL_DEFAULT=0\r
val SCE_MYSQL_COMMENT=1\r
val SCE_MYSQL_COMMENTLINE=2\r
val SCE_MYSQL_VARIABLE=3\r
val SCE_MYSQL_SYSTEMVARIABLE=4\r
val SCE_MYSQL_KNOWNSYSTEMVARIABLE=5\r
val SCE_MYSQL_NUMBER=6\r
val SCE_MYSQL_MAJORKEYWORD=7\r
val SCE_MYSQL_KEYWORD=8\r
val SCE_MYSQL_DATABASEOBJECT=9\r
val SCE_MYSQL_PROCEDUREKEYWORD=10\r
val SCE_MYSQL_STRING=11\r
val SCE_MYSQL_SQSTRING=12\r
val SCE_MYSQL_DQSTRING=13\r
val SCE_MYSQL_OPERATOR=14\r
val SCE_MYSQL_FUNCTION=15\r
val SCE_MYSQL_IDENTIFIER=16\r
val SCE_MYSQL_QUOTEDIDENTIFIER=17\r
val SCE_MYSQL_USER1=18\r
val SCE_MYSQL_USER2=19\r
val SCE_MYSQL_USER3=20\r
val SCE_MYSQL_HIDDENCOMMAND=21\r
val SCE_MYSQL_PLACEHOLDER=22\r
# Lexical state for SCLEX_PO\r
lex Po=SCLEX_PO SCE_PO_\r
val SCE_PO_DEFAULT=0\r
val SCE_PO_COMMENT=1\r
val SCE_PO_MSGID=2\r
val SCE_PO_MSGID_TEXT=3\r
val SCE_PO_MSGSTR=4\r
val SCE_PO_MSGSTR_TEXT=5\r
val SCE_PO_MSGCTXT=6\r
val SCE_PO_MSGCTXT_TEXT=7\r
val SCE_PO_FUZZY=8\r
val SCE_PO_PROGRAMMER_COMMENT=9\r
val SCE_PO_REFERENCE=10\r
val SCE_PO_FLAGS=11\r
val SCE_PO_MSGID_TEXT_EOL=12\r
val SCE_PO_MSGSTR_TEXT_EOL=13\r
val SCE_PO_MSGCTXT_TEXT_EOL=14\r
val SCE_PO_ERROR=15\r
# Lexical states for SCLEX_PASCAL\r
lex Pascal=SCLEX_PASCAL SCE_PAS_\r
val SCE_PAS_DEFAULT=0\r
val SCE_PAS_IDENTIFIER=1\r
val SCE_PAS_COMMENT=2\r
val SCE_PAS_COMMENT2=3\r
val SCE_PAS_COMMENTLINE=4\r
val SCE_PAS_PREPROCESSOR=5\r
val SCE_PAS_PREPROCESSOR2=6\r
val SCE_PAS_NUMBER=7\r
val SCE_PAS_HEXNUMBER=8\r
val SCE_PAS_WORD=9\r
val SCE_PAS_STRING=10\r
val SCE_PAS_STRINGEOL=11\r
val SCE_PAS_CHARACTER=12\r
val SCE_PAS_OPERATOR=13\r
val SCE_PAS_ASM=14\r
# Lexical state for SCLEX_SORCUS\r
lex SORCUS=SCLEX_SORCUS SCE_SORCUS_\r
val SCE_SORCUS_DEFAULT=0\r
val SCE_SORCUS_COMMAND=1\r
val SCE_SORCUS_PARAMETER=2\r
val SCE_SORCUS_COMMENTLINE=3\r
val SCE_SORCUS_STRING=4\r
val SCE_SORCUS_STRINGEOL=5\r
val SCE_SORCUS_IDENTIFIER=6\r
val SCE_SORCUS_OPERATOR=7\r
val SCE_SORCUS_NUMBER=8\r
val SCE_SORCUS_CONSTANT=9\r
# Lexical state for SCLEX_POWERPRO\r
lex PowerPro=SCLEX_POWERPRO SCE_POWERPRO_\r
val SCE_POWERPRO_DEFAULT=0\r
val SCE_POWERPRO_COMMENTBLOCK=1\r
val SCE_POWERPRO_COMMENTLINE=2\r
val SCE_POWERPRO_NUMBER=3\r
val SCE_POWERPRO_WORD=4\r
val SCE_POWERPRO_WORD2=5\r
val SCE_POWERPRO_WORD3=6\r
val SCE_POWERPRO_WORD4=7\r
val SCE_POWERPRO_DOUBLEQUOTEDSTRING=8\r
val SCE_POWERPRO_SINGLEQUOTEDSTRING=9\r
val SCE_POWERPRO_LINECONTINUE=10\r
val SCE_POWERPRO_OPERATOR=11\r
val SCE_POWERPRO_IDENTIFIER=12\r
val SCE_POWERPRO_STRINGEOL=13\r
val SCE_POWERPRO_VERBATIM=14\r
val SCE_POWERPRO_ALTQUOTE=15\r
val SCE_POWERPRO_FUNCTION=16\r
# Lexical states for SCLEX_SML\r
lex SML=SCLEX_SML SCE_SML_\r
val SCE_SML_DEFAULT=0\r
val SCE_SML_IDENTIFIER=1\r
val SCE_SML_TAGNAME=2\r
val SCE_SML_KEYWORD=3\r
val SCE_SML_KEYWORD2=4\r
val SCE_SML_KEYWORD3=5\r
val SCE_SML_LINENUM=6\r
val SCE_SML_OPERATOR=7\r
val SCE_SML_NUMBER=8\r
val SCE_SML_CHAR=9\r
val SCE_SML_STRING=11\r
val SCE_SML_COMMENT=12\r
val SCE_SML_COMMENT1=13\r
val SCE_SML_COMMENT2=14\r
val SCE_SML_COMMENT3=15\r
# Lexical state for SCLEX_MARKDOWN\r
lex Markdown=SCLEX_MARKDOWN SCE_MARKDOWN_\r
val SCE_MARKDOWN_DEFAULT=0\r
val SCE_MARKDOWN_LINE_BEGIN=1\r
val SCE_MARKDOWN_STRONG1=2\r
val SCE_MARKDOWN_STRONG2=3\r
val SCE_MARKDOWN_EM1=4\r
val SCE_MARKDOWN_EM2=5\r
val SCE_MARKDOWN_HEADER1=6\r
val SCE_MARKDOWN_HEADER2=7\r
val SCE_MARKDOWN_HEADER3=8\r
val SCE_MARKDOWN_HEADER4=9\r
val SCE_MARKDOWN_HEADER5=10\r
val SCE_MARKDOWN_HEADER6=11\r
val SCE_MARKDOWN_PRECHAR=12\r
val SCE_MARKDOWN_ULIST_ITEM=13\r
val SCE_MARKDOWN_OLIST_ITEM=14\r
val SCE_MARKDOWN_BLOCKQUOTE=15\r
val SCE_MARKDOWN_STRIKEOUT=16\r
val SCE_MARKDOWN_HRULE=17\r
val SCE_MARKDOWN_LINK=18\r
val SCE_MARKDOWN_CODE=19\r
val SCE_MARKDOWN_CODE2=20\r
val SCE_MARKDOWN_CODEBK=21\r
# Lexical state for SCLEX_TXT2TAGS\r
lex Txt2tags=SCLEX_TXT2TAGS SCE_TXT2TAGS_\r
val SCE_TXT2TAGS_DEFAULT=0\r
val SCE_TXT2TAGS_LINE_BEGIN=1\r
val SCE_TXT2TAGS_STRONG1=2\r
val SCE_TXT2TAGS_STRONG2=3\r
val SCE_TXT2TAGS_EM1=4\r
val SCE_TXT2TAGS_EM2=5\r
val SCE_TXT2TAGS_HEADER1=6\r
val SCE_TXT2TAGS_HEADER2=7\r
val SCE_TXT2TAGS_HEADER3=8\r
val SCE_TXT2TAGS_HEADER4=9\r
val SCE_TXT2TAGS_HEADER5=10\r
val SCE_TXT2TAGS_HEADER6=11\r
val SCE_TXT2TAGS_PRECHAR=12\r
val SCE_TXT2TAGS_ULIST_ITEM=13\r
val SCE_TXT2TAGS_OLIST_ITEM=14\r
val SCE_TXT2TAGS_BLOCKQUOTE=15\r
val SCE_TXT2TAGS_STRIKEOUT=16\r
val SCE_TXT2TAGS_HRULE=17\r
val SCE_TXT2TAGS_LINK=18\r
val SCE_TXT2TAGS_CODE=19\r
val SCE_TXT2TAGS_CODE2=20\r
val SCE_TXT2TAGS_CODEBK=21\r
val SCE_TXT2TAGS_COMMENT=22\r
val SCE_TXT2TAGS_OPTION=23\r
val SCE_TXT2TAGS_PREPROC=24\r
val SCE_TXT2TAGS_POSTPROC=25\r
# Lexical states for SCLEX_A68K\r
lex A68k=SCLEX_A68K SCE_A68K_\r
val SCE_A68K_DEFAULT=0\r
val SCE_A68K_COMMENT=1\r
val SCE_A68K_NUMBER_DEC=2\r
val SCE_A68K_NUMBER_BIN=3\r
val SCE_A68K_NUMBER_HEX=4\r
val SCE_A68K_STRING1=5\r
val SCE_A68K_OPERATOR=6\r
val SCE_A68K_CPUINSTRUCTION=7\r
val SCE_A68K_EXTINSTRUCTION=8\r
val SCE_A68K_REGISTER=9\r
val SCE_A68K_DIRECTIVE=10\r
val SCE_A68K_MACRO_ARG=11\r
val SCE_A68K_LABEL=12\r
val SCE_A68K_STRING2=13\r
val SCE_A68K_IDENTIFIER=14\r
val SCE_A68K_MACRO_DECLARATION=15\r
val SCE_A68K_COMMENT_WORD=16\r
val SCE_A68K_COMMENT_SPECIAL=17\r
val SCE_A68K_COMMENT_DOXYGEN=18\r
# Lexical states for SCLEX_MODULA\r
lex Modula=SCLEX_MODULA SCE_MODULA_\r
val SCE_MODULA_DEFAULT=0\r
val SCE_MODULA_COMMENT=1\r
val SCE_MODULA_DOXYCOMM=2\r
val SCE_MODULA_DOXYKEY=3\r
val SCE_MODULA_KEYWORD=4\r
val SCE_MODULA_RESERVED=5\r
val SCE_MODULA_NUMBER=6\r
val SCE_MODULA_BASENUM=7\r
val SCE_MODULA_FLOAT=8\r
val SCE_MODULA_STRING=9\r
val SCE_MODULA_STRSPEC=10\r
val SCE_MODULA_CHAR=11\r
val SCE_MODULA_CHARSPEC=12\r
val SCE_MODULA_PROC=13\r
val SCE_MODULA_PRAGMA=14\r
val SCE_MODULA_PRGKEY=15\r
val SCE_MODULA_OPERATOR=16\r
val SCE_MODULA_BADSTR=17\r
# Lexical states for SCLEX_COFFEESCRIPT\r
lex CoffeeScript=SCLEX_COFFEESCRIPT SCE_COFFEESCRIPT_\r
val SCE_COFFEESCRIPT_DEFAULT=0\r
val SCE_COFFEESCRIPT_COMMENT=1\r
val SCE_COFFEESCRIPT_COMMENTLINE=2\r
val SCE_COFFEESCRIPT_COMMENTDOC=3\r
val SCE_COFFEESCRIPT_NUMBER=4\r
val SCE_COFFEESCRIPT_WORD=5\r
val SCE_COFFEESCRIPT_STRING=6\r
val SCE_COFFEESCRIPT_CHARACTER=7\r
val SCE_COFFEESCRIPT_UUID=8\r
val SCE_COFFEESCRIPT_PREPROCESSOR=9\r
val SCE_COFFEESCRIPT_OPERATOR=10\r
val SCE_COFFEESCRIPT_IDENTIFIER=11\r
val SCE_COFFEESCRIPT_STRINGEOL=12\r
val SCE_COFFEESCRIPT_VERBATIM=13\r
val SCE_COFFEESCRIPT_REGEX=14\r
val SCE_COFFEESCRIPT_COMMENTLINEDOC=15\r
val SCE_COFFEESCRIPT_WORD2=16\r
val SCE_COFFEESCRIPT_COMMENTDOCKEYWORD=17\r
val SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR=18\r
val SCE_COFFEESCRIPT_GLOBALCLASS=19\r
val SCE_COFFEESCRIPT_STRINGRAW=20\r
val SCE_COFFEESCRIPT_TRIPLEVERBATIM=21\r
val SCE_COFFEESCRIPT_COMMENTBLOCK=22\r
val SCE_COFFEESCRIPT_VERBOSE_REGEX=23\r
val SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT=24\r
# Lexical states for SCLEX_AVS\r
lex AVS=SCLEX_AVS SCE_AVS_\r
val SCE_AVS_DEFAULT=0\r
val SCE_AVS_COMMENTBLOCK=1\r
val SCE_AVS_COMMENTBLOCKN=2\r
val SCE_AVS_COMMENTLINE=3\r
val SCE_AVS_NUMBER=4\r
val SCE_AVS_OPERATOR=5\r
val SCE_AVS_IDENTIFIER=6\r
val SCE_AVS_STRING=7\r
val SCE_AVS_TRIPLESTRING=8\r
val SCE_AVS_KEYWORD=9\r
val SCE_AVS_FILTER=10\r
val SCE_AVS_PLUGIN=11\r
val SCE_AVS_FUNCTION=12\r
val SCE_AVS_CLIPPROP=13\r
val SCE_AVS_USERDFN=14\r
# Lexical states for SCLEX_ECL\r
lex ECL=SCLEX_ECL SCE_ECL_\r
val SCE_ECL_DEFAULT=0\r
val SCE_ECL_COMMENT=1\r
val SCE_ECL_COMMENTLINE=2\r
val SCE_ECL_NUMBER=3\r
val SCE_ECL_STRING=4\r
val SCE_ECL_WORD0=5\r
val SCE_ECL_OPERATOR=6\r
val SCE_ECL_CHARACTER=7\r
val SCE_ECL_UUID=8\r
val SCE_ECL_PREPROCESSOR=9\r
val SCE_ECL_UNKNOWN=10\r
val SCE_ECL_IDENTIFIER=11\r
val SCE_ECL_STRINGEOL=12\r
val SCE_ECL_VERBATIM=13\r
val SCE_ECL_REGEX=14\r
val SCE_ECL_COMMENTLINEDOC=15\r
val SCE_ECL_WORD1=16\r
val SCE_ECL_COMMENTDOCKEYWORD=17\r
val SCE_ECL_COMMENTDOCKEYWORDERROR=18\r
val SCE_ECL_WORD2=19\r
val SCE_ECL_WORD3=20\r
val SCE_ECL_WORD4=21\r
val SCE_ECL_WORD5=22\r
val SCE_ECL_COMMENTDOC=23\r
val SCE_ECL_ADDED=24\r
val SCE_ECL_DELETED=25\r
val SCE_ECL_CHANGED=26\r
val SCE_ECL_MOVED=27\r
# Lexical states for SCLEX_OSCRIPT\r
lex OScript=SCLEX_OSCRIPT SCE_OSCRIPT_\r
val SCE_OSCRIPT_DEFAULT=0\r
val SCE_OSCRIPT_LINE_COMMENT=1\r
val SCE_OSCRIPT_BLOCK_COMMENT=2\r
val SCE_OSCRIPT_DOC_COMMENT=3\r
val SCE_OSCRIPT_PREPROCESSOR=4\r
val SCE_OSCRIPT_NUMBER=5\r
val SCE_OSCRIPT_SINGLEQUOTE_STRING=6\r
val SCE_OSCRIPT_DOUBLEQUOTE_STRING=7\r
val SCE_OSCRIPT_CONSTANT=8\r
val SCE_OSCRIPT_IDENTIFIER=9\r
val SCE_OSCRIPT_GLOBAL=10\r
val SCE_OSCRIPT_KEYWORD=11\r
val SCE_OSCRIPT_OPERATOR=12\r
val SCE_OSCRIPT_LABEL=13\r
val SCE_OSCRIPT_TYPE=14\r
val SCE_OSCRIPT_FUNCTION=15\r
val SCE_OSCRIPT_OBJECT=16\r
val SCE_OSCRIPT_PROPERTY=17\r
val SCE_OSCRIPT_METHOD=18\r
# Lexical states for SCLEX_VISUALPROLOG\r
lex VisualProlog=SCLEX_VISUALPROLOG SCE_VISUALPROLOG_\r
val SCE_VISUALPROLOG_DEFAULT=0\r
val SCE_VISUALPROLOG_KEY_MAJOR=1\r
val SCE_VISUALPROLOG_KEY_MINOR=2\r
val SCE_VISUALPROLOG_KEY_DIRECTIVE=3\r
val SCE_VISUALPROLOG_COMMENT_BLOCK=4\r
val SCE_VISUALPROLOG_COMMENT_LINE=5\r
val SCE_VISUALPROLOG_COMMENT_KEY=6\r
val SCE_VISUALPROLOG_COMMENT_KEY_ERROR=7\r
val SCE_VISUALPROLOG_IDENTIFIER=8\r
val SCE_VISUALPROLOG_VARIABLE=9\r
val SCE_VISUALPROLOG_ANONYMOUS=10\r
val SCE_VISUALPROLOG_NUMBER=11\r
val SCE_VISUALPROLOG_OPERATOR=12\r
val SCE_VISUALPROLOG_CHARACTER=13\r
val SCE_VISUALPROLOG_CHARACTER_TOO_MANY=14\r
val SCE_VISUALPROLOG_CHARACTER_ESCAPE_ERROR=15\r
val SCE_VISUALPROLOG_STRING=16\r
val SCE_VISUALPROLOG_STRING_ESCAPE=17\r
val SCE_VISUALPROLOG_STRING_ESCAPE_ERROR=18\r
val SCE_VISUALPROLOG_STRING_EOL_OPEN=19\r
val SCE_VISUALPROLOG_STRING_VERBATIM=20\r
val SCE_VISUALPROLOG_STRING_VERBATIM_SPECIAL=21\r
val SCE_VISUALPROLOG_STRING_VERBATIM_EOL=22\r
# Lexical states for SCLEX_STTXT\r
lex StructuredText=SCLEX_STTXT SCE_STTXT_\r
val SCE_STTXT_DEFAULT=0\r
val SCE_STTXT_COMMENT=1\r
val SCE_STTXT_COMMENTLINE=2\r
val SCE_STTXT_KEYWORD=3\r
val SCE_STTXT_TYPE=4\r
val SCE_STTXT_FUNCTION=5\r
val SCE_STTXT_FB=6\r
val SCE_STTXT_NUMBER=7\r
val SCE_STTXT_HEXNUMBER=8\r
val SCE_STTXT_PRAGMA=9\r
val SCE_STTXT_OPERATOR=10\r
val SCE_STTXT_CHARACTER=11\r
val SCE_STTXT_STRING1=12\r
val SCE_STTXT_STRING2=13\r
val SCE_STTXT_STRINGEOL=14\r
val SCE_STTXT_IDENTIFIER=15\r
val SCE_STTXT_DATETIME=16\r
val SCE_STTXT_VARS=17\r
val SCE_STTXT_PRAGMAS=18\r
# Lexical states for SCLEX_KVIRC\r
lex KVIrc=SCLEX_KVIRC SCE_KVIRC_\r
val SCE_KVIRC_DEFAULT=0\r
val SCE_KVIRC_COMMENT=1\r
val SCE_KVIRC_COMMENTBLOCK=2\r
val SCE_KVIRC_STRING=3\r
val SCE_KVIRC_WORD=4\r
val SCE_KVIRC_KEYWORD=5\r
val SCE_KVIRC_FUNCTION_KEYWORD=6\r
val SCE_KVIRC_FUNCTION=7\r
val SCE_KVIRC_VARIABLE=8\r
val SCE_KVIRC_NUMBER=9\r
val SCE_KVIRC_OPERATOR=10\r
val SCE_KVIRC_STRING_FUNCTION=11\r
val SCE_KVIRC_STRING_VARIABLE=12\r
# Lexical states for SCLEX_RUST\r
lex Rust=SCLEX_RUST SCE_RUST_\r
val SCE_RUST_DEFAULT=0\r
val SCE_RUST_COMMENTBLOCK=1\r
val SCE_RUST_COMMENTLINE=2\r
val SCE_RUST_COMMENTBLOCKDOC=3\r
val SCE_RUST_COMMENTLINEDOC=4\r
val SCE_RUST_NUMBER=5\r
val SCE_RUST_WORD=6\r
val SCE_RUST_WORD2=7\r
val SCE_RUST_WORD3=8\r
val SCE_RUST_WORD4=9\r
val SCE_RUST_WORD5=10\r
val SCE_RUST_WORD6=11\r
val SCE_RUST_WORD7=12\r
val SCE_RUST_STRING=13\r
val SCE_RUST_STRINGR=14\r
val SCE_RUST_CHARACTER=15\r
val SCE_RUST_OPERATOR=16\r
val SCE_RUST_IDENTIFIER=17\r
val SCE_RUST_LIFETIME=18\r
val SCE_RUST_MACRO=19\r
val SCE_RUST_LEXERROR=20\r
val SCE_RUST_BYTESTRING=21\r
val SCE_RUST_BYTESTRINGR=22\r
val SCE_RUST_BYTECHARACTER=23\r
# Lexical states for SCLEX_DMAP\r
lex DMAP=SCLEX_DMAP SCE_DMAP_\r
val SCE_DMAP_DEFAULT=0\r
val SCE_DMAP_COMMENT=1\r
val SCE_DMAP_NUMBER=2\r
val SCE_DMAP_STRING1=3\r
val SCE_DMAP_STRING2=4\r
val SCE_DMAP_STRINGEOL=5\r
val SCE_DMAP_OPERATOR=6\r
val SCE_DMAP_IDENTIFIER=7\r
val SCE_DMAP_WORD=8\r
val SCE_DMAP_WORD2=9\r
val SCE_DMAP_WORD3=10\r
# Lexical states for SCLEX_DMIS\r
lex DMIS=SCLEX_DMIS SCE_DMIS_\r
val SCE_DMIS_DEFAULT=0\r
val SCE_DMIS_COMMENT=1\r
val SCE_DMIS_STRING=2\r
val SCE_DMIS_NUMBER=3\r
val SCE_DMIS_KEYWORD=4\r
val SCE_DMIS_MAJORWORD=5\r
val SCE_DMIS_MINORWORD=6\r
val SCE_DMIS_UNSUPPORTED_MAJOR=7\r
val SCE_DMIS_UNSUPPORTED_MINOR=8\r
val SCE_DMIS_LABEL=9\r
# Lexical states for SCLEX_REGISTRY\r
lex REG=SCLEX_REGISTRY SCE_REG_\r
val SCE_REG_DEFAULT=0\r
val SCE_REG_COMMENT=1\r
val SCE_REG_VALUENAME=2\r
val SCE_REG_STRING=3\r
val SCE_REG_HEXDIGIT=4\r
val SCE_REG_VALUETYPE=5\r
val SCE_REG_ADDEDKEY=6\r
val SCE_REG_DELETEDKEY=7\r
val SCE_REG_ESCAPED=8\r
val SCE_REG_KEYPATH_GUID=9\r
val SCE_REG_STRING_GUID=10\r
val SCE_REG_PARAMETER=11\r
val SCE_REG_OPERATOR=12\r
# Lexical state for SCLEX_BIBTEX\r
lex BibTeX=SCLEX_BIBTEX SCE_BIBTEX_\r
val SCE_BIBTEX_DEFAULT=0\r
val SCE_BIBTEX_ENTRY=1\r
val SCE_BIBTEX_UNKNOWN_ENTRY=2\r
val SCE_BIBTEX_KEY=3\r
val SCE_BIBTEX_PARAMETER=4\r
val SCE_BIBTEX_VALUE=5\r
val SCE_BIBTEX_COMMENT=6\r
# Lexical state for SCLEX_SREC\r
lex Srec=SCLEX_SREC SCE_HEX_\r
val SCE_HEX_DEFAULT=0\r
val SCE_HEX_RECSTART=1\r
val SCE_HEX_RECTYPE=2\r
val SCE_HEX_RECTYPE_UNKNOWN=3\r
val SCE_HEX_BYTECOUNT=4\r
val SCE_HEX_BYTECOUNT_WRONG=5\r
val SCE_HEX_NOADDRESS=6\r
val SCE_HEX_DATAADDRESS=7\r
val SCE_HEX_RECCOUNT=8\r
val SCE_HEX_STARTADDRESS=9\r
val SCE_HEX_ADDRESSFIELD_UNKNOWN=10\r
val SCE_HEX_EXTENDEDADDRESS=11\r
val SCE_HEX_DATA_ODD=12\r
val SCE_HEX_DATA_EVEN=13\r
val SCE_HEX_DATA_UNKNOWN=14\r
val SCE_HEX_DATA_EMPTY=15\r
val SCE_HEX_CHECKSUM=16\r
val SCE_HEX_CHECKSUM_WRONG=17\r
val SCE_HEX_GARBAGE=18\r
# Lexical state for SCLEX_IHEX (shared with Srec)\r
lex IHex=SCLEX_IHEX SCE_HEX_\r
# Lexical state for SCLEX_TEHEX (shared with Srec)\r
lex TEHex=SCLEX_TEHEX SCE_HEX_\r
\r
# Events\r
\r
evt void StyleNeeded=2000(int position)\r
evt void CharAdded=2001(int ch)\r
evt void SavePointReached=2002(void)\r
evt void SavePointLeft=2003(void)\r
evt void ModifyAttemptRO=2004(void)\r
# GTK+ Specific to work around focus and accelerator problems:\r
evt void Key=2005(int ch, int modifiers)\r
evt void DoubleClick=2006(int modifiers, int position, int line)\r
evt void UpdateUI=2007(int updated)\r
evt void Modified=2008(int position, int modificationType, string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev, int token, int annotationLinesAdded)\r
evt void MacroRecord=2009(int message, int wParam, int lParam)\r
evt void MarginClick=2010(int modifiers, int position, int margin)\r
evt void NeedShown=2011(int position, int length)\r
evt void Painted=2013(void)\r
evt void UserListSelection=2014(int listType, string text, int position)\r
evt void URIDropped=2015(string text)\r
evt void DwellStart=2016(int position, int x, int y)\r
evt void DwellEnd=2017(int position, int x, int y)\r
evt void Zoom=2018(void)\r
evt void HotSpotClick=2019(int modifiers, int position)\r
evt void HotSpotDoubleClick=2020(int modifiers, int position)\r
evt void CallTipClick=2021(int position)\r
evt void AutoCSelection=2022(string text, int position)\r
evt void IndicatorClick=2023(int modifiers, int position)\r
evt void IndicatorRelease=2024(int modifiers, int position)\r
evt void AutoCCancelled=2025(void)\r
evt void AutoCCharDeleted=2026(void)\r
evt void HotSpotReleaseClick=2027(int modifiers, int position)\r
evt void FocusIn=2028(void)\r
evt void FocusOut=2029(void)\r
\r
# There are no provisional features currently\r
\r
cat Provisional\r
\r
cat Deprecated\r
\r
# Deprecated in 2.21\r
# The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+.\r
val SC_CP_DBCS=1\r
\r
# Deprecated in 2.30\r
\r
# In palette mode?\r
get bool GetUsePalette=2139(,)\r
\r
# In palette mode, Scintilla uses the environment's palette calls to display\r
# more colours. This may lead to ugly displays.\r
set void SetUsePalette=2039(bool usePalette,)\r
\r
# Deprecated in 3.5.5\r
\r
# Always interpret keyboard input as Unicode\r
set void SetKeysUnicode=2521(bool keysUnicode,)\r
\r
# Are keys always interpreted as Unicode?\r
get bool GetKeysUnicode=2522(,)\r