mirror of
https://github.com/rizonesoft/Notepad3.git
synced 2026-06-14 21:09:05 +08:00
Merge pull request #3453 from RaiKoHoff/Dev_RC1
Update Lexilla Lib (bug fixes for Lexer: Markdown, Cmd/Batch)
This commit is contained in:
Rainer Kottenhoff
GitHub
commit
ac1c7940d4
@ -146,7 +146,7 @@
|
||||
<LanguageStandard_C>stdc17</LanguageStandard_C>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<TargetMachine>MachineX86</TargetMachine>
|
||||
<AdditionalDependencies>shlwapi.lib;Urlmon.lib;UxTheme.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
@ -174,7 +174,7 @@
|
||||
<LanguageStandard_C>stdc17</LanguageStandard_C>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<AdditionalDependencies>shlwapi.lib;Urlmon.lib;UxTheme.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<CETCompat>true</CETCompat>
|
||||
|
||||
@ -950,6 +950,7 @@
|
||||
#define IDS_LEX_PRISM_CSV 63050
|
||||
#define IDS_LEX_DART_SRC 63051
|
||||
#define IDS_LEX_KOTLIN_SRC 63052
|
||||
#define IDS_LEX_JULIA_SCR 63053
|
||||
|
||||
#define IDS_LEX_STD_STYLE 63100
|
||||
#define IDS_LEX_STD_MARGIN 63101
|
||||
|
||||
@ -127,6 +127,7 @@ BEGIN
|
||||
IDS_LEX_TOML_CFG "TOML"
|
||||
IDS_LEX_DART_SRC "Dart Source Code"
|
||||
IDS_LEX_KOTLIN_SRC "Kotlin Source Code"
|
||||
IDS_LEX_JULIA_SCR "Julia Script"
|
||||
END
|
||||
|
||||
STRINGTABLE
|
||||
|
||||
@ -127,6 +127,7 @@ BEGIN
|
||||
IDS_LEX_TOML_CFG "TOML"
|
||||
IDS_LEX_DART_SRC "Dart Source Code"
|
||||
IDS_LEX_KOTLIN_SRC "Kotlin Source Code"
|
||||
IDS_LEX_JULIA_SCR "Julia Script"
|
||||
END
|
||||
|
||||
STRINGTABLE
|
||||
|
||||
@ -66,6 +66,7 @@
|
||||
<ClCompile Include="lexers\LexDiff.cxx" />
|
||||
<ClCompile Include="lexers\LexHTML.cxx" />
|
||||
<ClCompile Include="lexers\LexInno.cxx" />
|
||||
<ClCompile Include="lexers\LexJulia.cxx" />
|
||||
<ClCompile Include="lexers\LexLaTeX.cxx" />
|
||||
<ClCompile Include="lexers\LexLua.cxx" />
|
||||
<ClCompile Include="lexers\LexMake.cxx" />
|
||||
@ -231,13 +232,14 @@
|
||||
<StringPooling>true</StringPooling>
|
||||
<FloatingPointModel>Precise</FloatingPointModel>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<FunctionLevelLinking>false</FunctionLevelLinking>
|
||||
<EnableEnhancedInstructionSet />
|
||||
<OmitFramePointers />
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
<SmallerTypeCheck>false</SmallerTypeCheck>
|
||||
<TreatWarningAsError>true</TreatWarningAsError>
|
||||
<LanguageStandard_C>stdc17</LanguageStandard_C>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@ -338,12 +340,13 @@
|
||||
<StringPooling>true</StringPooling>
|
||||
<FloatingPointModel>Precise</FloatingPointModel>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<FunctionLevelLinking>false</FunctionLevelLinking>
|
||||
<EnableEnhancedInstructionSet />
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
<SmallerTypeCheck>false</SmallerTypeCheck>
|
||||
<TreatWarningAsError>true</TreatWarningAsError>
|
||||
<LanguageStandard_C>stdc17</LanguageStandard_C>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
|
||||
@ -263,6 +263,9 @@
|
||||
<ClCompile Include="lexers_x\LexerUtils.cxx">
|
||||
<Filter>lexers_x</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="lexers\LexJulia.cxx">
|
||||
<Filter>lexers</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ResourceCompile Include="src\LexillaVersion.rc">
|
||||
|
||||
@ -32,7 +32,9 @@ constParameter:lexilla/lexers/LexBash.cxx
|
||||
uninitMemberVar:lexilla/lexers/LexBash.cxx
|
||||
variableScope:lexilla/lexers/LexBash.cxx
|
||||
variableScope:lexilla/lexers/LexBatch.cxx
|
||||
knownConditionTrueFalse:lexilla/lexers/LexBatch.cxx
|
||||
knownConditionTrueFalse:lexilla/lexers/LexBibTeX.cxx
|
||||
constStatement:lexilla/lexers/LexCaml.cxx
|
||||
variableScope:lexilla/lexers/LexCmake.cxx
|
||||
knownConditionTrueFalse:lexilla/lexers/LexCmake.cxx
|
||||
constParameter:lexilla/lexers/LexCLW.cxx
|
||||
@ -52,6 +54,9 @@ constParameter:lexilla/lexers/LexHaskell.cxx
|
||||
constParameter:lexilla/lexers/LexHex.cxx
|
||||
constParameter:lexilla/lexers/LexHTML.cxx
|
||||
variableScope:lexilla/lexers/LexInno.cxx
|
||||
variableScope:lexilla/lexers/LexJulia.cxx
|
||||
constParameter:lexilla/lexers/LexJulia.cxx
|
||||
unreadVariable:lexilla/lexers/LexJulia.cxx
|
||||
variableScope:lexilla/lexers/LexLaTeX.cxx
|
||||
constParameter:lexilla/lexers/LexLaTeX.cxx
|
||||
constParameter:lexilla/lexers/LexLisp.cxx
|
||||
|
||||
@ -562,6 +562,9 @@
|
||||
<td>Derek Brown</td>
|
||||
</tr><tr>
|
||||
<td>Robert Di Pardo</td>
|
||||
<td>riQQ</td>
|
||||
<td>YX Hao</td>
|
||||
<td>Bertrand Lacoste</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2>Releases</h2>
|
||||
@ -576,16 +579,37 @@
|
||||
Add namespace feature with GetNameSpace function.
|
||||
</li>
|
||||
<li>
|
||||
Add Julia lexer.
|
||||
<a href="https://sourceforge.net/p/scintilla/feature-requests/1380/">Feature #1380</a>.
|
||||
</li>
|
||||
<li>
|
||||
Fix transition to comment for --> inside JavaScript string.
|
||||
<a href="https://sourceforge.net/p/scintilla/bugs/2207/">Bug #2207</a>.
|
||||
</li>
|
||||
<li>
|
||||
Fix variable expansion in Batch.
|
||||
<a href="https://github.com/ScintillaOrg/lexilla/issues/4">Issue #4</a>.
|
||||
</li>
|
||||
<li>
|
||||
Fix empty link titles in Markdown.
|
||||
<a href="https://sourceforge.net/p/scintilla/bugs/2235/">Bug #2235</a>.
|
||||
Also fix detection of whether the previous line had content which treated '\n' and '\r\n' line endings differently.
|
||||
</li>
|
||||
<li>
|
||||
Remove nested comment and long string support as these were removed from Lua.
|
||||
<a href="https://sourceforge.net/p/scintilla/bugs/2205/">Bug #2205</a>.
|
||||
</li>
|
||||
<li>
|
||||
Update to Unicode 13.
|
||||
<a href="https://sourceforge.net/p/scintilla/feature-requests/1379/">Feature #1379</a>.
|
||||
</li>
|
||||
<li>
|
||||
AddStaticLexerModule function adds a static lexer to Lexilla's list.
|
||||
</li>
|
||||
<li>
|
||||
On Win32 enable hardware-enforced stack protection.
|
||||
<a href="https://sourceforge.net/p/scintilla/feature-requests/1405/">Feature #1405</a>.
|
||||
</li>
|
||||
</ul>
|
||||
<h3>
|
||||
<a href="https://www.scintilla.org/lexilla502.zip">Release 5.0.2</a>
|
||||
|
||||
@ -141,6 +141,7 @@ val SCLEX_DATAFLEX=129
|
||||
val SCLEX_HOLLYWOOD=130
|
||||
val SCLEX_RAKU=131
|
||||
val SCLEX_FSHARP=132
|
||||
val SCLEX_JULIA=133
|
||||
|
||||
# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
|
||||
# value assigned in sequence from SCLEX_AUTOMATIC+1.
|
||||
@ -1047,6 +1048,28 @@ val SCE_ERLANG_MODULES_ATT=24
|
||||
val SCE_ERLANG_UNKNOWN=31
|
||||
# Lexical states for SCLEX_OCTAVE are identical to MatLab
|
||||
lex Octave=SCLEX_OCTAVE SCE_MATLAB_
|
||||
# Lexical states for SCLEX_JULIA
|
||||
lex Julia=SCLEX_JULIA SCE_JULIA_
|
||||
val SCE_JULIA_DEFAULT=0
|
||||
val SCE_JULIA_COMMENT=1
|
||||
val SCE_JULIA_NUMBER=2
|
||||
val SCE_JULIA_KEYWORD1=3
|
||||
val SCE_JULIA_KEYWORD2=4
|
||||
val SCE_JULIA_KEYWORD3=5
|
||||
val SCE_JULIA_CHAR=6
|
||||
val SCE_JULIA_OPERATOR=7
|
||||
val SCE_JULIA_BRACKET=8
|
||||
val SCE_JULIA_IDENTIFIER=9
|
||||
val SCE_JULIA_STRING=10
|
||||
val SCE_JULIA_SYMBOL=11
|
||||
val SCE_JULIA_MACRO=12
|
||||
val SCE_JULIA_STRINGINTERP=13
|
||||
val SCE_JULIA_DOCSTRING=14
|
||||
val SCE_JULIA_STRINGLITERAL=15
|
||||
val SCE_JULIA_COMMAND=16
|
||||
val SCE_JULIA_COMMANDLITERAL=17
|
||||
val SCE_JULIA_TYPEANNOT=18
|
||||
val SCE_JULIA_LEXERROR=19
|
||||
# Lexical states for SCLEX_MSSQL
|
||||
lex MSSQL=SCLEX_MSSQL SCE_MSSQL_
|
||||
val SCE_MSSQL_DEFAULT=0
|
||||
|
||||
@ -145,6 +145,7 @@
|
||||
#define SCLEX_HOLLYWOOD 130
|
||||
#define SCLEX_RAKU 131
|
||||
#define SCLEX_FSHARP 132
|
||||
#define SCLEX_JULIA 133
|
||||
#define SCLEX_AUTOMATIC 1000
|
||||
#define SCE_P_DEFAULT 0
|
||||
#define SCE_P_COMMENTLINE 1
|
||||
@ -932,6 +933,26 @@
|
||||
#define SCE_ERLANG_MODULES 23
|
||||
#define SCE_ERLANG_MODULES_ATT 24
|
||||
#define SCE_ERLANG_UNKNOWN 31
|
||||
#define SCE_JULIA_DEFAULT 0
|
||||
#define SCE_JULIA_COMMENT 1
|
||||
#define SCE_JULIA_NUMBER 2
|
||||
#define SCE_JULIA_KEYWORD1 3
|
||||
#define SCE_JULIA_KEYWORD2 4
|
||||
#define SCE_JULIA_KEYWORD3 5
|
||||
#define SCE_JULIA_CHAR 6
|
||||
#define SCE_JULIA_OPERATOR 7
|
||||
#define SCE_JULIA_BRACKET 8
|
||||
#define SCE_JULIA_IDENTIFIER 9
|
||||
#define SCE_JULIA_STRING 10
|
||||
#define SCE_JULIA_SYMBOL 11
|
||||
#define SCE_JULIA_MACRO 12
|
||||
#define SCE_JULIA_STRINGINTERP 13
|
||||
#define SCE_JULIA_DOCSTRING 14
|
||||
#define SCE_JULIA_STRINGLITERAL 15
|
||||
#define SCE_JULIA_COMMAND 16
|
||||
#define SCE_JULIA_COMMANDLITERAL 17
|
||||
#define SCE_JULIA_TYPEANNOT 18
|
||||
#define SCE_JULIA_LEXERROR 19
|
||||
#define SCE_MSSQL_DEFAULT 0
|
||||
#define SCE_MSSQL_COMMENT 1
|
||||
#define SCE_MSSQL_LINE_COMMENT 2
|
||||
|
||||
@ -423,14 +423,54 @@ static void ColouriseBatchDoc(
|
||||
// Reset Offset to re-process remainder of word
|
||||
offset -= (wbl - 2);
|
||||
// Check for Expanded Argument (%~...) / Variable (%%~...)
|
||||
// Expanded Argument: %~[<path-operators>]<single digit>
|
||||
// Expanded Variable: %%~[<path-operators>]<single identifier character>
|
||||
// Path operators are exclusively alphabetic.
|
||||
// Expanded arguments have a single digit at the end.
|
||||
// Expanded variables have a single identifier character as variable name.
|
||||
} else if (((wbl > 1) && (wordBuffer[1] == '~')) ||
|
||||
((wbl > 2) && (wordBuffer[1] == '%') && (wordBuffer[2] == '~'))) {
|
||||
// Check for External Command / Program
|
||||
if (cmdLoc == offset - wbl) {
|
||||
cmdLoc = offset - (wbl - wbo);
|
||||
}
|
||||
// Colorize Expanded Argument / Variable
|
||||
styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
|
||||
bool isArgument = (wordBuffer[1] == '~');
|
||||
if (isArgument) {
|
||||
Sci_PositionU expansionStopOffset = 2;
|
||||
bool isValid = false;
|
||||
for (; expansionStopOffset < wbl; expansionStopOffset++) {
|
||||
if (isArgument && Is0To9(wordBuffer[expansionStopOffset])) {
|
||||
expansionStopOffset++;
|
||||
isValid = true;
|
||||
wbo = expansionStopOffset;
|
||||
// Colorize Expanded Argument
|
||||
styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!isValid) {
|
||||
// not a valid expanded argument or variable
|
||||
styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
|
||||
}
|
||||
// Expanded Variable
|
||||
} else {
|
||||
// start after ~
|
||||
wbo = 3;
|
||||
// Search to end of word for another % (can be a long path)
|
||||
while ((wbo < wbl) &&
|
||||
(wordBuffer[wbo] != '%') &&
|
||||
(!IsBOperator(wordBuffer[wbo])) &&
|
||||
(!IsBSeparator(wordBuffer[wbo]))) {
|
||||
wbo++;
|
||||
}
|
||||
if (wbo > 3) {
|
||||
// Colorize Expanded Variable
|
||||
styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
|
||||
} else {
|
||||
// not a valid expanded argument or variable
|
||||
styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
|
||||
}
|
||||
}
|
||||
// Reset Offset to re-process remainder of word
|
||||
offset -= (wbl - wbo);
|
||||
// Check for Environment Variable (%x...%)
|
||||
|
||||
1220
lexilla/lexers/LexJulia.cxx
Normal file
1220
lexilla/lexers/LexJulia.cxx
Normal file
File diff suppressed because it is too large
Load Diff
@ -69,17 +69,15 @@ static void ColouriseLuaDoc(
|
||||
CharacterSet setEscapeSkip(CharacterSet::setNone, "\"'\\");
|
||||
|
||||
Sci_Position currentLine = styler.GetLine(startPos);
|
||||
// Initialize long string [[ ... ]] or block comment --[[ ... ]] nesting level,
|
||||
// Initialize long string [[ ... ]] or block comment --[[ ... ]],
|
||||
// if we are inside such a string. Block comment was introduced in Lua 5.0,
|
||||
// blocks with separators [=[ ... ]=] in Lua 5.1.
|
||||
// Continuation of a string (\z whitespace escaping) is controlled by stringWs.
|
||||
int nestLevel = 0;
|
||||
int sepCount = 0;
|
||||
int stringWs = 0;
|
||||
if (initStyle == SCE_LUA_LITERALSTRING || initStyle == SCE_LUA_COMMENT ||
|
||||
initStyle == SCE_LUA_STRING || initStyle == SCE_LUA_CHARACTER) {
|
||||
const int lineState = styler.GetLineState(currentLine - 1);
|
||||
nestLevel = lineState >> 9;
|
||||
sepCount = lineState & 0xFF;
|
||||
stringWs = lineState & 0x100;
|
||||
}
|
||||
@ -110,7 +108,7 @@ static void ColouriseLuaDoc(
|
||||
case SCE_LUA_STRING:
|
||||
case SCE_LUA_CHARACTER:
|
||||
// Inside a literal string, block comment or string, we set the line state
|
||||
styler.SetLineState(currentLine, (nestLevel << 9) | stringWs | sepCount);
|
||||
styler.SetLineState(currentLine, stringWs | sepCount);
|
||||
break;
|
||||
default:
|
||||
// Reset the line state
|
||||
@ -254,25 +252,11 @@ static void ColouriseLuaDoc(
|
||||
sc.ChangeState(SCE_LUA_STRINGEOL);
|
||||
sc.ForwardSetState(SCE_LUA_DEFAULT);
|
||||
}
|
||||
} else if (sc.state == SCE_LUA_LITERALSTRING || sc.state == SCE_LUA_COMMENT) {
|
||||
if (sc.ch == '[') {
|
||||
const int sep = LongDelimCheck(sc);
|
||||
if (sep == 1 && sepCount == 1) { // [[-only allowed to nest
|
||||
nestLevel++;
|
||||
sc.Forward();
|
||||
}
|
||||
} else if (sc.ch == ']') {
|
||||
int sep = LongDelimCheck(sc);
|
||||
if (sep == 1 && sepCount == 1) { // un-nest with ]]-only
|
||||
nestLevel--;
|
||||
sc.Forward();
|
||||
if (nestLevel == 0) {
|
||||
sc.ForwardSetState(SCE_LUA_DEFAULT);
|
||||
}
|
||||
} else if (sep > 1 && sep == sepCount) { // ]=]-style delim
|
||||
sc.Forward(sep);
|
||||
sc.ForwardSetState(SCE_LUA_DEFAULT);
|
||||
}
|
||||
} else if (sc.ch == ']' && (sc.state == SCE_LUA_LITERALSTRING || sc.state == SCE_LUA_COMMENT)) {
|
||||
const int sep = LongDelimCheck(sc);
|
||||
if (sep == sepCount) { // ]=]-style delim
|
||||
sc.Forward(sep);
|
||||
sc.ForwardSetState(SCE_LUA_DEFAULT);
|
||||
}
|
||||
}
|
||||
|
||||
@ -356,7 +340,6 @@ static void ColouriseLuaDoc(
|
||||
if (sepCount == 0) {
|
||||
sc.SetState(SCE_LUA_OPERATOR);
|
||||
} else {
|
||||
nestLevel = 1;
|
||||
sc.SetState(SCE_LUA_LITERALSTRING);
|
||||
sc.Forward(sepCount);
|
||||
}
|
||||
@ -366,7 +349,6 @@ static void ColouriseLuaDoc(
|
||||
sc.Forward(2);
|
||||
sepCount = LongDelimCheck(sc);
|
||||
if (sepCount > 0) {
|
||||
nestLevel = 1;
|
||||
sc.ChangeState(SCE_LUA_COMMENT);
|
||||
sc.Forward(sepCount);
|
||||
}
|
||||
@ -384,7 +366,7 @@ static void ColouriseLuaDoc(
|
||||
sc.Complete();
|
||||
}
|
||||
|
||||
static void FoldLuaDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
|
||||
static void FoldLuaDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
|
||||
Accessor &styler) {
|
||||
const Sci_PositionU lengthDoc = startPos + length;
|
||||
int visibleChars = 0;
|
||||
@ -393,12 +375,14 @@ static void FoldLuaDoc(Sci_PositionU startPos, Sci_Position length, int /* initS
|
||||
int levelCurrent = levelPrev;
|
||||
char chNext = styler[startPos];
|
||||
const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
|
||||
int style = initStyle;
|
||||
int styleNext = styler.StyleAt(startPos);
|
||||
|
||||
for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
|
||||
const char ch = chNext;
|
||||
chNext = styler.SafeGetCharAt(i + 1);
|
||||
const int style = styleNext;
|
||||
const int stylePrev = style;
|
||||
style = styleNext;
|
||||
styleNext = styler.StyleAt(i + 1);
|
||||
const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
|
||||
if (style == SCE_LUA_WORD) {
|
||||
@ -426,9 +410,9 @@ static void FoldLuaDoc(Sci_PositionU startPos, Sci_Position length, int /* initS
|
||||
levelCurrent--;
|
||||
}
|
||||
} else if (style == SCE_LUA_LITERALSTRING || style == SCE_LUA_COMMENT) {
|
||||
if (ch == '[') {
|
||||
if (stylePrev != style) {
|
||||
levelCurrent++;
|
||||
} else if (ch == ']') {
|
||||
} else if (styleNext != style) {
|
||||
levelCurrent--;
|
||||
}
|
||||
}
|
||||
|
||||
@ -76,38 +76,25 @@ static bool FollowToLineEnd(const int ch, const int state, const Sci_PositionU e
|
||||
|
||||
// Set the state on text section from current to length characters,
|
||||
// then set the rest until the newline to default, except for any characters matching token
|
||||
|
||||
#if 0
|
||||
constexpr bool IsHdrToken(const int ch, const int tok) noexcept {
|
||||
return ((ch == tok) || (ch == ' ') || (ch == '\n') || (ch == '\r'));
|
||||
}
|
||||
|
||||
static void SetStateAndZoom(const int state, const Sci_Position length, const int token, StyleContext &sc) {
|
||||
sc.SetState(state);
|
||||
sc.Forward(length);
|
||||
bool tokenState = true;
|
||||
while (sc.More() && !sc.atLineStart) {
|
||||
if (IsHdrToken(sc.ch, token) && !tokenState) {
|
||||
sc.SetState(SCE_MARKDOWN_DEFAULT);
|
||||
sc.Forward();
|
||||
bool started = false;
|
||||
while (sc.More() && !IsNewline(sc.ch)) {
|
||||
if (sc.ch == token && !started) {
|
||||
sc.SetState(state);
|
||||
tokenState = true;
|
||||
started = true;
|
||||
}
|
||||
else if (!IsHdrToken(sc.ch, token) && tokenState) {
|
||||
sc.SetState(SCE_MARKDOWN_HDRTEXT);
|
||||
tokenState = false;
|
||||
else if (sc.ch != token) {
|
||||
sc.SetState(SCE_MARKDOWN_DEFAULT);
|
||||
started = false;
|
||||
}
|
||||
sc.Forward();
|
||||
}
|
||||
sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void SetStateAndZoom(const int state, const Sci_Position length, const int token, StyleContext &sc) {
|
||||
(void)(token);
|
||||
sc.SetState(state);
|
||||
sc.Forward(length);
|
||||
while (sc.More() && !sc.atLineStart) { sc.Forward(); }
|
||||
sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
|
||||
}
|
||||
|
||||
// Does the previous line have more than spaces and tabs?
|
||||
static bool HasPrevLineContent(StyleContext &sc) {
|
||||
@ -116,9 +103,10 @@ static bool HasPrevLineContent(StyleContext &sc) {
|
||||
while ((--i + (Sci_Position)sc.currentPos) >= 0 && !IsNewline(sc.GetRelative(i)))
|
||||
;
|
||||
while ((--i + (Sci_Position)sc.currentPos) >= 0) {
|
||||
if (IsNewline(sc.GetRelative(i)))
|
||||
const int ch = sc.GetRelative(i);
|
||||
if (ch == '\n')
|
||||
break;
|
||||
if (!IsASpaceOrTab(sc.GetRelative(i)))
|
||||
if (!((ch == '\r' || IsASpaceOrTab(ch))))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -252,36 +240,24 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
}
|
||||
else if (sc.state == SCE_MARKDOWN_LINE_BEGIN) {
|
||||
// Header
|
||||
if (sc.Match("######")) {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER6, 6, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
else if (sc.Match("#####")) {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER5, 5, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
else if (sc.Match("####")) {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER4, 4, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
else if (sc.Match("###")) {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER3, 3, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
else if (sc.Match("##")) {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER2, 2, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
if (sc.Match("######"))
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER6, 6, '#', sc);
|
||||
else if (sc.Match("#####"))
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER5, 5, '#', sc);
|
||||
else if (sc.Match("####"))
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER4, 4, '#', sc);
|
||||
else if (sc.Match("###"))
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER3, 3, '#', sc);
|
||||
else if (sc.Match("##"))
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER2, 2, '#', sc);
|
||||
else if (sc.Match("#")) {
|
||||
// Catch the special case of an unordered list
|
||||
if (sc.chNext == '.' && IsASpaceOrTab(sc.GetRelative(2))) {
|
||||
precharCount = 0;
|
||||
sc.SetState(SCE_MARKDOWN_PRECHAR);
|
||||
}
|
||||
else {
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER1, 1, '#', sc);
|
||||
freezeCursor = true;
|
||||
}
|
||||
else
|
||||
SetStateAndZoom(SCE_MARKDOWN_HEADER1, 1, '#', sc);
|
||||
}
|
||||
// Code block
|
||||
else if (sc.Match("~~~")) {
|
||||
@ -313,12 +289,12 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
}
|
||||
|
||||
// The header lasts until the newline
|
||||
else if (sc.state == SCE_MARKDOWN_HEADER1 || sc.state == SCE_MARKDOWN_HEADER2 ||
|
||||
sc.state == SCE_MARKDOWN_HEADER3 || sc.state == SCE_MARKDOWN_HEADER4 ||
|
||||
sc.state == SCE_MARKDOWN_HEADER5 || sc.state == SCE_MARKDOWN_HEADER6) {
|
||||
if (IsNewline(sc.ch))
|
||||
sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
|
||||
}
|
||||
else if (sc.state == SCE_MARKDOWN_HEADER1 || sc.state == SCE_MARKDOWN_HEADER2 ||
|
||||
sc.state == SCE_MARKDOWN_HEADER3 || sc.state == SCE_MARKDOWN_HEADER4 ||
|
||||
sc.state == SCE_MARKDOWN_HEADER5 || sc.state == SCE_MARKDOWN_HEADER6) {
|
||||
if (IsNewline(sc.ch))
|
||||
sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
|
||||
}
|
||||
|
||||
// New state only within the initial whitespace
|
||||
if (sc.state == SCE_MARKDOWN_PRECHAR) {
|
||||
@ -366,21 +342,22 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
// Any link
|
||||
if (sc.state == SCE_MARKDOWN_LINK) {
|
||||
if (sc.Match("](") && sc.GetRelative(-1) != '\\') {
|
||||
sc.Forward();
|
||||
sc.Forward(2);
|
||||
isLinkNameDetecting = true;
|
||||
}
|
||||
else if (sc.Match("]:") && sc.GetRelative(-1) != '\\') {
|
||||
sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
|
||||
sc.Forward(2);
|
||||
sc.SetState(SCE_MARKDOWN_DEFAULT);
|
||||
}
|
||||
else if (!isLinkNameDetecting && sc.ch == ']' && sc.GetRelative(-1) != '\\') {
|
||||
sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
|
||||
freezeCursor = true;
|
||||
sc.Forward();
|
||||
sc.SetState(SCE_MARKDOWN_DEFAULT);
|
||||
}
|
||||
else if (isLinkNameDetecting && sc.ch == ')' && sc.GetRelative(-1) != '\\') {
|
||||
sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
|
||||
freezeCursor = true;
|
||||
isLinkNameDetecting = false;
|
||||
}
|
||||
sc.Forward();
|
||||
sc.SetState(SCE_MARKDOWN_DEFAULT);
|
||||
isLinkNameDetecting = false;
|
||||
}
|
||||
}
|
||||
|
||||
// New state anywhere in doc
|
||||
@ -392,7 +369,7 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
// Links and Images
|
||||
if (sc.Match("![")) {
|
||||
sc.SetState(SCE_MARKDOWN_LINK);
|
||||
sc.Forward();
|
||||
sc.Forward(1);
|
||||
}
|
||||
else if (sc.ch == '[' && sc.GetRelative(-1) != '\\') {
|
||||
sc.SetState(SCE_MARKDOWN_LINK);
|
||||
@ -409,7 +386,7 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
else if (sc.Match("**") && sc.GetRelative(2) != ' ' && AtTermStart(sc)) {
|
||||
sc.SetState(SCE_MARKDOWN_STRONG1);
|
||||
sc.Forward();
|
||||
}
|
||||
}
|
||||
else if (sc.Match("__") && sc.GetRelative(2) != ' ' && AtTermStart(sc)) {
|
||||
sc.SetState(SCE_MARKDOWN_STRONG2);
|
||||
sc.Forward();
|
||||
@ -431,12 +408,10 @@ static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int
|
||||
sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
|
||||
}
|
||||
}
|
||||
|
||||
// Advance if not holding back the cursor for this iteration.
|
||||
if (!freezeCursor)
|
||||
sc.Forward();
|
||||
else
|
||||
freezeCursor = false;
|
||||
freezeCursor = false;
|
||||
}
|
||||
sc.Complete();
|
||||
}
|
||||
|
||||
@ -9,8 +9,7 @@ import os, pathlib, sys
|
||||
sys.path.append(os.path.join("..", "..", "scintilla", "scripts"))
|
||||
|
||||
import Face
|
||||
|
||||
from FileGenerator import UpdateFile, Generate, Regenerate, UpdateLineInFile, lineEnd
|
||||
import FileGenerator
|
||||
|
||||
def printLexHFile(f):
|
||||
out = []
|
||||
@ -21,10 +20,10 @@ def printLexHFile(f):
|
||||
out.append("#define " + name + " " + v["Value"])
|
||||
return out
|
||||
|
||||
def RegenerateAll(root, showMaxID):
|
||||
def RegenerateAll(root, _showMaxID):
|
||||
f = Face.Face()
|
||||
f.ReadFromFile(root / "include/LexicalStyles.iface")
|
||||
Regenerate(root / "include/SciLexer.h", "/* ", printLexHFile(f))
|
||||
FileGenerator.Regenerate(root / "include/SciLexer.h", "/* ", printLexHFile(f))
|
||||
|
||||
if __name__ == "__main__":
|
||||
RegenerateAll(pathlib.Path(__file__).resolve().parent.parent, True)
|
||||
|
||||
@ -173,7 +173,7 @@ def FindCredits(historyFile):
|
||||
credit = l[4:-5]
|
||||
if "<a" in l:
|
||||
title, a, rest = credit.partition("<a href=")
|
||||
urlplus, bracket, end = rest.partition(">")
|
||||
urlplus, _bracket, end = rest.partition(">")
|
||||
name = end.split("<")[0]
|
||||
url = urlplus[1:-1]
|
||||
credit = title.strip()
|
||||
|
||||
@ -48,6 +48,7 @@ extern LexerModule lmDiff;
|
||||
extern LexerModule lmHTML;
|
||||
extern LexerModule lmInno;
|
||||
extern LexerModule lmJSON;
|
||||
extern LexerModule lmJulia;
|
||||
extern LexerModule lmKotlin;
|
||||
extern LexerModule lmLatex;
|
||||
extern LexerModule lmLua;
|
||||
@ -112,6 +113,7 @@ void AddEachLexer() {
|
||||
&lmHTML,
|
||||
&lmInno,
|
||||
&lmJSON,
|
||||
&lmJulia,
|
||||
&lmKotlin,
|
||||
&lmLatex,
|
||||
&lmLua,
|
||||
|
||||
@ -158,6 +158,7 @@
|
||||
F6224FEE88B39060046EEBB0 /* LexerUtils.cxx in Sources */ = {isa = PBXBuildFile; fileRef = B70142AEAD02FCCC38C95437 /* LexerUtils.cxx */; };
|
||||
20734B2BAC0066B302C5F572 /* LexKotlin.cxx in Sources */ = {isa = PBXBuildFile; fileRef = 4B244DD685C45BD626DFCBFA /* LexKotlin.cxx */; };
|
||||
173A4B628003CD6778153F13 /* LexTOML.cxx in Sources */ = {isa = PBXBuildFile; fileRef = 8FE446A1AD4BC789488C9865 /* LexTOML.cxx */; };
|
||||
98684028BA6245805B2034D1 /* LexJulia.cxx in Sources */ = {isa = PBXBuildFile; fileRef = 9AA44B1D90573293F9570B5E /* LexJulia.cxx */; };
|
||||
/* End PBXBuildFile section */
|
||||
|
||||
/* Begin PBXFileReference section */
|
||||
@ -314,6 +315,7 @@
|
||||
B70142AEAD02FCCC38C95437 /* LexerUtils.cxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LexerUtils.cxx; path = ../../lexers/LexerUtils.cxx; sourceTree = SOURCE_ROOT; };
|
||||
4B244DD685C45BD626DFCBFA /* LexKotlin.cxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LexKotlin.cxx; path = ../../lexers/LexKotlin.cxx; sourceTree = SOURCE_ROOT; };
|
||||
8FE446A1AD4BC789488C9865 /* LexTOML.cxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LexTOML.cxx; path = ../../lexers/LexTOML.cxx; sourceTree = SOURCE_ROOT; };
|
||||
9AA44B1D90573293F9570B5E /* LexJulia.cxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LexJulia.cxx; path = ../../lexers/LexJulia.cxx; sourceTree = SOURCE_ROOT; };
|
||||
/* End PBXFileReference section */
|
||||
|
||||
/* Begin PBXFrameworksBuildPhase section */
|
||||
@ -413,6 +415,7 @@
|
||||
28BA72EA24E34D9300272C2D /* LexIndent.cxx */,
|
||||
28BA730524E34D9400272C2D /* LexInno.cxx */,
|
||||
28BA733024E34D9600272C2D /* LexJSON.cxx */,
|
||||
9AA44B1D90573293F9570B5E /* LexJulia.cxx */,
|
||||
28BA731124E34D9500272C2D /* LexKix.cxx */,
|
||||
4B244DD685C45BD626DFCBFA /* LexKotlin.cxx */,
|
||||
28BA72F824E34D9300272C2D /* LexKVIrc.cxx */,
|
||||
@ -736,6 +739,7 @@
|
||||
F6224FEE88B39060046EEBB0 /* LexerUtils.cxx in Sources */,
|
||||
20734B2BAC0066B302C5F572 /* LexKotlin.cxx in Sources */,
|
||||
173A4B628003CD6778153F13 /* LexTOML.cxx in Sources */,
|
||||
98684028BA6245805B2034D1 /* LexJulia.cxx in Sources */,
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
|
||||
@ -277,6 +277,22 @@ LexInno.o: \
|
||||
../lexlib/StyleContext.h \
|
||||
../lexlib/CharacterSet.h \
|
||||
../lexlib/LexerModule.h
|
||||
LexJulia.o: \
|
||||
../lexers/LexJulia.cxx \
|
||||
../../scintilla/include/ILexer.h \
|
||||
../../scintilla/include/Sci_Position.h \
|
||||
../../scintilla/include/Scintilla.h \
|
||||
../include/SciLexer.h \
|
||||
../lexlib/PropSetSimple.h \
|
||||
../lexlib/WordList.h \
|
||||
../lexlib/LexAccessor.h \
|
||||
../lexlib/Accessor.h \
|
||||
../lexlib/StyleContext.h \
|
||||
../lexlib/CharacterSet.h \
|
||||
../lexlib/CharacterCategory.h \
|
||||
../lexlib/LexerModule.h \
|
||||
../lexlib/OptionSet.h \
|
||||
../lexlib/DefaultLexer.h
|
||||
LexLaTeX.o: \
|
||||
../lexers/LexLaTeX.cxx \
|
||||
../../scintilla/include/ILexer.h \
|
||||
|
||||
@ -27,17 +27,20 @@ SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.02
|
||||
!ELSE
|
||||
SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.01
|
||||
!ENDIF
|
||||
!ELSEIFDEF ARM64
|
||||
!ELSE
|
||||
CETCOMPAT=-CETCOMPAT
|
||||
!IFDEF ARM64
|
||||
ADD_DEFINE=-D_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1
|
||||
SUBSYSTEM=-SUBSYSTEM:WINDOWS,10.00
|
||||
!ENDIF
|
||||
!ENDIF
|
||||
|
||||
CRTFLAGS=-D_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1 -D_CRT_SECURE_NO_DEPRECATE=1 -D_SCL_SECURE_NO_WARNINGS=1 $(ADD_DEFINE)
|
||||
CXXFLAGS=-Zi -TP -MP -W4 -EHsc -std:c++17 $(CRTFLAGS)
|
||||
CXXDEBUG=-Od -MTd -DDEBUG
|
||||
CXXNDEBUG=-O1 -MT -DNDEBUG -GL
|
||||
NAME=-Fo
|
||||
LDFLAGS=-OPT:REF -LTCG -IGNORE:4197 -DEBUG $(SUBSYSTEM)
|
||||
LDFLAGS=-OPT:REF -LTCG -IGNORE:4197 -DEBUG $(SUBSYSTEM) $(CETCOMPAT)
|
||||
LDDEBUG=
|
||||
LIBS=
|
||||
NOLOGO=-nologo
|
||||
@ -85,6 +88,7 @@ LEX_OBJS=\
|
||||
$(DIR_O)\LexDiff.obj \
|
||||
$(DIR_O)\LexHTML.obj \
|
||||
$(DIR_O)\LexInno.obj \
|
||||
$(DIR_O)\LexJulia.obj \
|
||||
$(DIR_O)\LexLaTeX.obj \
|
||||
$(DIR_O)\LexLua.obj \
|
||||
$(DIR_O)\LexMake.obj \
|
||||
|
||||
@ -277,6 +277,22 @@ $(DIR_O)/LexInno.obj: \
|
||||
../lexlib/StyleContext.h \
|
||||
../lexlib/CharacterSet.h \
|
||||
../lexlib/LexerModule.h
|
||||
$(DIR_O)/LexJulia.obj: \
|
||||
../lexers/LexJulia.cxx \
|
||||
../../scintilla/include/ILexer.h \
|
||||
../../scintilla/include/Sci_Position.h \
|
||||
../../scintilla/include/Scintilla.h \
|
||||
../include/SciLexer.h \
|
||||
../lexlib/PropSetSimple.h \
|
||||
../lexlib/WordList.h \
|
||||
../lexlib/LexAccessor.h \
|
||||
../lexlib/Accessor.h \
|
||||
../lexlib/StyleContext.h \
|
||||
../lexlib/CharacterSet.h \
|
||||
../lexlib/CharacterCategory.h \
|
||||
../lexlib/LexerModule.h \
|
||||
../lexlib/OptionSet.h \
|
||||
../lexlib/DefaultLexer.h
|
||||
$(DIR_O)/LexLaTeX.obj: \
|
||||
../lexers/LexLaTeX.cxx \
|
||||
../../scintilla/include/ILexer.h \
|
||||
|
||||
@ -143,7 +143,7 @@
|
||||
<AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
|
||||
<AdditionalDependencies>shlwapi.lib;muiload.lib;psapi.lib;legacy_stdio_definitions.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<SuppressStartupBanner>true</SuppressStartupBanner>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
|
||||
<ManifestFile />
|
||||
|
||||
@ -169,7 +169,7 @@
|
||||
<ClCompile>
|
||||
<AdditionalIncludeDirectories>include;src;../lexilla/inclide;../oniguruma/src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
|
||||
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
|
||||
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
|
||||
<MultiProcessorCompilation>true</MultiProcessorCompilation>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PrecompiledHeader>NotUsing</PrecompiledHeader>
|
||||
@ -183,7 +183,7 @@
|
||||
</EnableEnhancedInstructionSet>
|
||||
<FloatingPointModel>Precise</FloatingPointModel>
|
||||
<LanguageStandard>stdcpp17</LanguageStandard>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<FunctionLevelLinking>false</FunctionLevelLinking>
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
<TreatWarningAsError>true</TreatWarningAsError>
|
||||
<LanguageStandard_C>stdc17</LanguageStandard_C>
|
||||
@ -210,7 +210,7 @@
|
||||
<StringPooling>true</StringPooling>
|
||||
<FloatingPointModel>Precise</FloatingPointModel>
|
||||
<LanguageStandard>stdcpp17</LanguageStandard>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<FunctionLevelLinking>false</FunctionLevelLinking>
|
||||
<EnableEnhancedInstructionSet />
|
||||
<MinimalRebuild>false</MinimalRebuild>
|
||||
<TreatWarningAsError>true</TreatWarningAsError>
|
||||
|
||||
@ -1551,7 +1551,7 @@ HWND InitInstance(const HINSTANCE hInstance, LPCWSTR pszCmdLine, int nCmdShow)
|
||||
if (s_lpSchemeArg) {
|
||||
Style_SetLexerFromName(Globals.hwndEdit,Paths.CurrentFile,s_lpSchemeArg);
|
||||
LocalFree(s_lpSchemeArg); // StrDup()
|
||||
} else if ((s_iInitialLexer >= 0) && (s_iInitialLexer < NUMLEXERS)) {
|
||||
} else if ((s_iInitialLexer >= 0) && (s_iInitialLexer < Style_NumOfLexers())) {
|
||||
Style_SetLexerFromID(Globals.hwndEdit, s_iInitialLexer);
|
||||
}
|
||||
s_flagLexerSpecified = false;
|
||||
@ -3138,7 +3138,7 @@ LRESULT MsgCopyData(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||||
StringCchCopy(wchExt, COUNTOF(wchExt), L".");
|
||||
StringCchCopyN(CharNext(wchExt), 32, StrEnd(¶ms->wchData, 0) + 1, 31);
|
||||
Style_SetLexerFromName(Globals.hwndEdit, ¶ms->wchData, wchExt);
|
||||
} else if (params->iInitialLexer >= 0 && params->iInitialLexer < NUMLEXERS) {
|
||||
} else if (params->iInitialLexer >= 0 && params->iInitialLexer < Style_NumOfLexers()) {
|
||||
Style_SetLexerFromID(Globals.hwndEdit, params->iInitialLexer);
|
||||
}
|
||||
}
|
||||
|
||||
@ -174,7 +174,7 @@
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<AdditionalDependencies>ntdll.lib;comctl32.lib;imm32.lib;shlwapi.lib;muiload.lib;scintilla.lib;lexilla.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<GenerateDebugInformation>Debug</GenerateDebugInformation>
|
||||
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<TargetMachine>MachineX86</TargetMachine>
|
||||
<AdditionalLibraryDirectories>$(IntermediateOutputPath);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
|
||||
@ -248,7 +248,7 @@
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<AdditionalDependencies>ntdll.lib;comctl32.lib;imm32.lib;shlwapi.lib;muiload.lib;scintilla.lib;lexilla.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<GenerateDebugInformation>Debug</GenerateDebugInformation>
|
||||
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<TargetMachine>MachineX64</TargetMachine>
|
||||
<AdditionalLibraryDirectories>$(IntermediateOutputPath);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
|
||||
@ -624,6 +624,7 @@
|
||||
<ClCompile Include="crypto\sha-256.c" />
|
||||
<ClCompile Include="StyleLexers\EditLexer.c" />
|
||||
<ClCompile Include="StyleLexers\styleLexDart.c" />
|
||||
<ClCompile Include="StyleLexers\styleLexJulia.c" />
|
||||
<ClCompile Include="StyleLexers\styleLexKotlin.c" />
|
||||
<ClCompile Include="tinyexpr\tinyexpr.c" />
|
||||
<ClCompile Include="uchardet\uchardet\src\CharDistribution.cpp" />
|
||||
|
||||
@ -414,6 +414,9 @@
|
||||
<ClCompile Include="StyleLexers\EditLexer.c">
|
||||
<Filter>Source Files\StyleLexers</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="StyleLexers\styleLexJulia.c">
|
||||
<Filter>Source Files\StyleLexers</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="Dlapi.h">
|
||||
|
||||
@ -113,6 +113,7 @@ extern EDITLEXER lexINNO; // Inno Setup Script
|
||||
extern EDITLEXER lexJAVA; // Java Source Code
|
||||
extern EDITLEXER lexJS; // JavaScript
|
||||
extern EDITLEXER lexJSON; // JSON
|
||||
extern EDITLEXER lexJulia; // JSON
|
||||
extern EDITLEXER lexKotlin; // Kotlin
|
||||
extern EDITLEXER lexLATEX; // LaTeX Files
|
||||
extern EDITLEXER lexLUA; // Lua Script
|
||||
|
||||
88
src/StyleLexers/styleLexJulia.c
Normal file
88
src/StyleLexers/styleLexJulia.c
Normal file
@ -0,0 +1,88 @@
|
||||
#include "StyleLexers.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
//KEYWORDLIST KeyWords_Julia = EMPTY_KEYWORDLIST;
|
||||
KEYWORDLIST KeyWords_Julia =
|
||||
{
|
||||
// 0 Primary keywords and identifiers
|
||||
"abstract baremodule begin break catch const continue do else elseif end export finally for function global "
|
||||
"if import in isa let local macro module mutable primitive quote return struct try type using var where while "
|
||||
|
||||
, // 1 Built in types
|
||||
"AbstractArray AbstractArrayStyle AbstractChannel AbstractChar AbstractDict AbstractDisplay AbstractFloat "
|
||||
"AbstractIrrational AbstractLock AbstractLogger AbstractMatrix AbstractRNG AbstractRange "
|
||||
"AbstractSet AbstractSparseArray AbstractSparseMatrix AbstractSparseVector AbstractString AbstractUnitRange "
|
||||
"AbstractVecOrMat AbstractVector AbstractWorkerPool Adjoint Anonymous Any ArgumentError Array ArrayStyle "
|
||||
"AssertionError AsyncCondition Atomic "
|
||||
"Base64DecodePipe Base64EncodePipe Bidiagonal BigFloat BigInt BitArray BitMatrix BitSet BitVector Bool BoundsError "
|
||||
"BroadcastStyle "
|
||||
"CFunction CapturedException CartesianIndex CartesianIndices Cchar Cdouble Cfloat Channel Char Cint Cintmax_t "
|
||||
"Clong Clonglong ClusterManager Cmd "
|
||||
"Colon Complex ComplexF16 ComplexF32 ComplexF64 CompositeException CompoundPeriod Condition ConsoleLogger Cptrdiff_t "
|
||||
"Cshort Csize_t Cssize_t Cstring Cuchar Cuint Cuintmax_t Culong Culonglong Cushort Cwchar_t Cwstring "
|
||||
"DataType Date DateFormat DateTime Day DefaultArrayStyle DenseArray DenseMatrix DenseVecOrMat DenseVector "
|
||||
"Diagonal Dict DimensionMismatch Dims DivideError DomainError "
|
||||
"EOFError Enum EnvDict ErrorException Event Exception ExponentialBackOff Expr Float16 Float32 Float64 Function Future "
|
||||
"Givens GlobalRef Hermitian Hour "
|
||||
"IO IOBuffer IOContext IOStream IPAddr IPv4 IPv6 IdDict ImmutableDict IndexCartesian IndexLinear IndexStyle InexactError "
|
||||
"InitError Instant Int Int128 Int16 Int32 Int64 Int8 Integer InterruptException InvalidStateException Irrational "
|
||||
"IteratorEltype IteratorSize "
|
||||
"KeyError LinRange LineNumberNode LinearIndices LoadError LogLevel LowerTriangular "
|
||||
"MIME Matrix MersenneTwister Method MethodError Microsecond Millisecond Minute Missing MissingException Module Month "
|
||||
"Mutex "
|
||||
"NTuple NamedTuple Nanosecond Nothing NullLogger Number OneTo OrdinalRange OutOfMemoryError OverflowError "
|
||||
"Pair Pairs PartialQuickSort Period PermutedDimsArray Pipe PipeBuffer PosDefException ProcessFailedException Ptr "
|
||||
"QR QRCompactWY QRPivoted QuoteNode "
|
||||
"Random RandomDevice Rational RawFD "
|
||||
"ReadOnlyMemoryError Real ReentrantLock Ref Regex RegexMatch RemoteChannel RemoteException RoundingMode "
|
||||
"Second SegmentationFault Semaphore Serialization Set SharedArray SharedMatrix SharedVector "
|
||||
"Signed SimpleLogger SingularException Some SparseMatrixCSC SparseVector SpinLock "
|
||||
"StackFrame StackOverflowError StackTrace Stateful StepRange StepRangeLen "
|
||||
"StridedArray StridedMatrix StridedVecOrMat StridedVector String StringIndexError SubArray SubString SubstitutionString "
|
||||
"SymTridiagonal Symbol Symmetric SystemError "
|
||||
"TCPSocket Task TextDisplay Time TimeType Timer TmStruct Transpose Tridiagonal Tuple Type TypeError TypeVar "
|
||||
"UDPSocket UInt UInt128 UInt16 UInt32 UInt64 UInt8 UTInstant "
|
||||
"UndefInitializer UndefKeywordError UndefRefError UndefVarError "
|
||||
"UniformScaling Union UnionAll UnitLowerTriangular UnitRange UnitUpperTriangular Unsigned UpperTriangular "
|
||||
"Val Vararg VecElement VecOrMat Vector VersionNumber WeakKeyDict WeakRef Week WorkerConfig WorkerPool Year "
|
||||
|
||||
, // 2 Other keywords
|
||||
"allocated assert async boundscheck cfunction debug deprecate distributed dump "
|
||||
"elapsed enum error eval evalpoly everywhere fastmath fetch generated gensym goto "
|
||||
"inbounds inferred info inline isdefined label logmsg lower macroexpand macroexpand1 noinline nospecialize "
|
||||
"polly preserve printf profile propagate_inbounds pure show spawn spawnat specialize sprintf static sync "
|
||||
"task test test_broken test_deprecated test_logs test_nowarn test_skip test_throws test_warn testset threads "
|
||||
"time timed timev "
|
||||
"view views warn "
|
||||
|
||||
, // 3 Raw string literals
|
||||
"raw "
|
||||
|
||||
, NULL
|
||||
};
|
||||
|
||||
|
||||
EDITLEXER lexJulia =
|
||||
{
|
||||
SCLEX_JULIA, "julia", IDS_LEX_JULIA_SCR, L"Julia Script", L"jl", L"",
|
||||
&KeyWords_Julia, {
|
||||
{ { STYLE_DEFAULT }, IDS_LEX_STR_63126, L"Default", L"", L"" },
|
||||
//{ {SCE_JULIA_DEFAULT}, IDS_LEX_STR_63126, L"Default", L"", L"" },
|
||||
{ { SCE_JULIA_COMMENT }, IDS_LEX_STR_63127, L"Comment", L"fore:#608060", L"" },
|
||||
{ { SCE_JULIA_NUMBER }, IDS_LEX_STR_63130, L"Number", L"fore:#FF0000", L"" },
|
||||
{ { SCE_JULIA_KEYWORD1 }, IDS_LEX_STR_63128, L"Keyword", L"bold; fore:#0000FF", L"" },
|
||||
{ { MULTI_STYLE(SCE_JULIA_KEYWORD2, SCE_JULIA_KEYWORD3, 0, 0) }, IDS_LEX_STR_63260, L"Keyword 2nd", L"bold; fore:#8A008A", L"" },
|
||||
{ { MULTI_STYLE(SCE_JULIA_CHAR, SCE_JULIA_STRING, 0, 0) }, IDS_LEX_STR_63131, L"String", L"fore:#BB2F00", L"" },
|
||||
{ { MULTI_STYLE(SCE_JULIA_OPERATOR, SCE_JULIA_BRACKET, 0, 0) }, IDS_LEX_STR_63132, L"Operator", L"fore:#B53A00", L"" },
|
||||
{ { SCE_JULIA_IDENTIFIER }, IDS_LEX_STR_63129, L"Identifier", L"fore:#00007B", L"" },
|
||||
{ { SCE_JULIA_SYMBOL }, IDS_LEX_STR_63293, L"Symbol", L"fore:#C0A030", L"" },
|
||||
{ { SCE_JULIA_MACRO }, IDS_LEX_STR_63280, L"Macro Def", L"fore:#0080FF", L"" },
|
||||
{ { SCE_JULIA_DOCSTRING }, IDS_LEX_STR_63259, L"Comment Doc", L"fore:#808080", L"" },
|
||||
{ { MULTI_STYLE(SCE_JULIA_STRINGINTERP, SCE_JULIA_STRINGLITERAL, 0, 0) }, IDS_LEX_STR_63301, L"Literal String", L"fore:#B000B0", L"" },
|
||||
{ { MULTI_STYLE(SCE_JULIA_COMMAND, SCE_JULIA_COMMANDLITERAL, 0, 0) }, IDS_LEX_STR_63236, L"Command", L"bold; fore:#0000DD", L"" },
|
||||
{ { SCE_JULIA_TYPEANNOT }, IDS_LEX_STR_63370, L"Annotation", L"fore:#FF8000", L"" },
|
||||
{ { SCE_JULIA_LEXERROR }, IDS_LEX_STR_63252, L"Parsing Error", L"fore:#FFFF00; back:#A00000; eolfilled", L"" },
|
||||
EDITLEXER_SENTINEL
|
||||
}
|
||||
};
|
||||
11
src/Styles.c
11
src/Styles.c
@ -49,7 +49,7 @@ extern COLORREF g_colorCustom[16];
|
||||
// This array holds all the lexers...
|
||||
// Don't forget to change the number of the lexer for HTML and XML
|
||||
// in Notepad2.c ParseCommandLine() if you change this array!
|
||||
static PEDITLEXER g_pLexArray[NUMLEXERS] = {
|
||||
static PEDITLEXER g_pLexArray[] = {
|
||||
&lexStandard, // Default Text
|
||||
&lexStandard2nd, // 2nd Default Text
|
||||
&lexTEXT, // Pure Text Files (Constants.StdDefaultLexerID = 2)
|
||||
@ -76,6 +76,7 @@ static PEDITLEXER g_pLexArray[NUMLEXERS] = {
|
||||
&lexJAVA, // Java Source Code
|
||||
&lexJS, // JavaScript
|
||||
&lexJSON, // JSON
|
||||
&lexJulia, // Julia
|
||||
&lexKotlin, // Kotlin
|
||||
&lexLATEX, // LaTeX Files
|
||||
&lexLUA, // Lua Script
|
||||
@ -105,6 +106,10 @@ static PEDITLEXER g_pLexArray[NUMLEXERS] = {
|
||||
&lexYAML, // YAML
|
||||
};
|
||||
|
||||
int Style_NumOfLexers() {
|
||||
return COUNTOF(g_pLexArray);
|
||||
}
|
||||
|
||||
|
||||
// Currently used lexer
|
||||
static PEDITLEXER s_pLexCurrent = &lexStandard;
|
||||
@ -3940,7 +3945,7 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd, UINT umsg, WPARAM wPar
|
||||
static HBRUSH hbrBack = { 0 };
|
||||
static bool bIsStyleSelected = false;
|
||||
static bool bWarnedNoIniFile = false;
|
||||
static WCHAR* Style_StylesBackup[NUMLEXERS * AVG_NUM_OF_STYLES_PER_LEXER];
|
||||
static WCHAR *Style_StylesBackup[COUNTOF(g_pLexArray) * AVG_NUM_OF_STYLES_PER_LEXER];
|
||||
|
||||
static WCHAR tchTmpBuffer[max(BUFSIZE_STYLE_VALUE, BUFZIZE_STYLE_EXTENTIONS)] = {L'\0'};
|
||||
|
||||
@ -3978,7 +3983,7 @@ INT_PTR CALLBACK Style_CustomizeSchemesDlgProc(HWND hwnd, UINT umsg, WPARAM wPar
|
||||
SetDlgItemText(hwnd, IDC_STYLEEDIT_HELP, tchTmpBuffer);
|
||||
|
||||
// Backup Styles
|
||||
ZeroMemory(&Style_StylesBackup, NUMLEXERS * AVG_NUM_OF_STYLES_PER_LEXER * sizeof(WCHAR*));
|
||||
ZeroMemory(&Style_StylesBackup, COUNTOF(g_pLexArray) * AVG_NUM_OF_STYLES_PER_LEXER * sizeof(WCHAR*));
|
||||
int cnt = 0;
|
||||
for (int iLexer = 0; iLexer < COUNTOF(g_pLexArray); ++iLexer) {
|
||||
Style_StylesBackup[cnt++] = StrDup(g_pLexArray[iLexer]->szExtensions);
|
||||
|
||||
@ -28,8 +28,8 @@
|
||||
#define NUMBER_OF_MARGINS 3
|
||||
|
||||
// Number of Lexers in pLexArray
|
||||
#define NUMLEXERS 53
|
||||
#define AVG_NUM_OF_STYLES_PER_LEXER 20
|
||||
int Style_NumOfLexers();
|
||||
|
||||
void Style_Load();
|
||||
bool Style_Import(HWND hwnd);
|
||||
|
||||
434
test/test_files/StyleLexers/styleLexJulia/x.jl
Normal file
434
test/test_files/StyleLexers/styleLexJulia/x.jl
Normal file
@ -0,0 +1,434 @@
|
||||
|
||||
# Comment here
|
||||
const bar = '\n'
|
||||
|
||||
"""
|
||||
test_fun(a::Int)
|
||||
For test only
|
||||
"""
|
||||
function test_fun(a::Int, b::T) where T <: Number
|
||||
println(a)
|
||||
println("foo $(bar)")
|
||||
end
|
||||
|
||||
@enum Unicode α=1 β=2
|
||||
|
||||
res = [√i for i in 1:10]
|
||||
|
||||
#= Dummy function =#
|
||||
test_fun²(:sym, true, raw"test", `echo 1`)
|
||||
|
||||
# function to calculate the volume of a sphere
|
||||
function sphere_vol(r)
|
||||
# julia allows Unicode names (in UTF-8 encoding)
|
||||
# so either "pi" or the symbol π can be used
|
||||
return 4/3*pi*r^3
|
||||
end
|
||||
|
||||
# functions can also be defined more succinctly
|
||||
quadratic(a, sqr_term, b) = (-b + sqr_term) / 2a
|
||||
|
||||
# calculates x for 0 = a*x^2+b*x+c, arguments types can be defined in function definitions
|
||||
function quadratic2(a::Float64, b::Float64, c::Float64)
|
||||
# unlike other languages 2a is equivalent to 2*a
|
||||
# a^2 is used instead of a**2 or pow(a,2)
|
||||
sqr_term = sqrt(b^2-4a*c)
|
||||
r1 = quadratic(a, sqr_term, b)
|
||||
r2 = quadratic(a, -sqr_term, b)
|
||||
# multiple values can be returned from a function using tuples
|
||||
# if the return keyword is omitted, the last term is returned
|
||||
r1, r2
|
||||
end
|
||||
|
||||
vol = sphere_vol(3)
|
||||
# @printf allows number formatting but does not automatically append the \n to statements, see below
|
||||
using Printf
|
||||
@printf "volume = %0.3f\n" vol
|
||||
#> volume = 113.097
|
||||
|
||||
quad1, quad2 = quadratic2(2.0, -2.0, -12.0)
|
||||
println("result 1: ", quad1)
|
||||
#> result 1: 3.0
|
||||
println("result 2: ", quad2)
|
||||
#> result 2: -2.0
|
||||
|
||||
s1 = "The quick brown fox jumps over the lazy dog α,β,γ"
|
||||
|
||||
# search returns the first index of a char
|
||||
i = findfirst(isequal('b'), s1)
|
||||
println(i)
|
||||
#> 11
|
||||
# the second argument is equivalent to the second argument of split, see below
|
||||
|
||||
# or a range if called with another string
|
||||
r = findfirst("brown", s1)
|
||||
println(r)
|
||||
#> 11:15
|
||||
|
||||
|
||||
# string replace is done thus:
|
||||
r = replace(s1, "brown" => "red")
|
||||
show(r); println()
|
||||
#> "The quick red fox jumps over the lazy dog α,β,γ"
|
||||
|
||||
# search and replace can also take a regular expressions by preceding the string with 'r'
|
||||
r = findfirst(r"b[\w]*n", s1)
|
||||
println(r)
|
||||
#> 11:15
|
||||
|
||||
# again with a regular expression
|
||||
r = replace(s1, r"b[\w]*n" => "red")
|
||||
show(r); println()
|
||||
#> "The quick red fox jumps over the lazy dog α,β,γ"
|
||||
|
||||
# there are also functions for regular expressions that return RegexMatch types
|
||||
# match scans left to right for the first match (specified starting index optional)
|
||||
r = match(r"b[\w]*n", s1)
|
||||
println(r)
|
||||
#> RegexMatch("brown")
|
||||
|
||||
# RegexMatch types have a property match that holds the matched string
|
||||
show(r.match); println()
|
||||
#> "brown"
|
||||
|
||||
# eachmatch returns an iterator over all the matches
|
||||
r = eachmatch(r"[\w]{4,}", s1)
|
||||
for i in r print("\"$(i.match)\" ") end
|
||||
#> "quick" "brown" "jumps" "over" "lazy"
|
||||
println()
|
||||
|
||||
|
||||
r = collect(m.match for m = eachmatch(r"[\w]{4,}", s1))
|
||||
println(r)
|
||||
#> SubString{String}["quick", "brown", "jumps", "over", "lazy"]
|
||||
|
||||
# a string can be repeated using the repeat function,
|
||||
# or more succinctly with the ^ syntax:
|
||||
r = "hello "^3
|
||||
show(r); println() #> "hello hello hello "
|
||||
|
||||
# the strip function works the same as python:
|
||||
# e.g., with one argument it strips the outer whitespace
|
||||
r = strip("hello ")
|
||||
show(r); println() #> "hello"
|
||||
# or with a second argument of an array of chars it strips any of them;
|
||||
r = strip("hello ", ['h', ' '])
|
||||
show(r); println() #> "ello"
|
||||
# (note the array is of chars and not strings)
|
||||
|
||||
# similarly split works in basically the same way as python:
|
||||
r = split("hello, there,bob", ',')
|
||||
show(r); println() #> SubString{String}["hello", " there", "bob"]
|
||||
r = split("hello, there,bob", ", ")
|
||||
show(r); println() #> SubString{String}["hello", "there,bob"]
|
||||
r = split("hello, there,bob", [',', ' '], limit=0, keepempty=false)
|
||||
show(r); println() #> SubString{String}["hello", "there", "bob"]
|
||||
# (the last two arguements are limit and include_empty, see docs)
|
||||
|
||||
# the opposite of split: join is simply
|
||||
r = join(collect(1:10), ", ")
|
||||
println(r) #> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
|
||||
|
||||
function printsum(a)
|
||||
# summary generates a summary of an object
|
||||
println(summary(a), ": ", repr(a))
|
||||
end
|
||||
|
||||
# arrays can be initialised directly:
|
||||
a1 = [1,2,3]
|
||||
printsum(a1)
|
||||
#> 3-element Array{Int64,1}: [1, 2, 3]
|
||||
|
||||
# or initialised empty:
|
||||
a2 = []
|
||||
printsum(a2)
|
||||
#> 0-element Array{Any,1}: Any[]
|
||||
|
||||
# since this array has no type, functions like push! (see below) don't work
|
||||
# instead arrays can be initialised with a type:
|
||||
a3 = Int64[]
|
||||
printsum(a3)
|
||||
#> 0-element Array{Int64,1}: Int64[]
|
||||
|
||||
# ranges are different from arrays:
|
||||
a4 = 1:20
|
||||
printsum(a4)
|
||||
#> 20-element UnitRange{Int64}: 1:20
|
||||
|
||||
# however they can be used to create arrays thus:
|
||||
a4 = collect(1:20)
|
||||
printsum(a4)
|
||||
#> 20-element Array{Int64,1}: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
|
||||
#> 15, 16, 17, 18, 19, 20]
|
||||
|
||||
# arrays can also be generated from comprehensions:
|
||||
a5 = [2^i for i = 1:10]
|
||||
printsum(a5)
|
||||
#> 10-element Array{Int64,1}: [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
||||
|
||||
# arrays can be any type, so arrays of arrays can be created:
|
||||
a6 = (Array{Int64, 1})[]
|
||||
printsum(a6)
|
||||
#> 0-element Array{Array{Int64,1},1}: Array{Int64,1}[]
|
||||
# (note this is a "jagged array" (i.e., an array of arrays), not a multidimensional array,
|
||||
# these are not covered here)
|
||||
|
||||
# Julia provided a number of "Dequeue" functions, the most common
|
||||
# for appending to the end of arrays is push!
|
||||
# ! at the end of a function name indicates that the first argument is updated.
|
||||
|
||||
push!(a1, 4)
|
||||
printsum(a1)
|
||||
#> 4-element Array{Int64,1}: [1, 2, 3, 4]
|
||||
|
||||
# push!(a2, 1) would cause error:
|
||||
|
||||
push!(a3, 1)
|
||||
printsum(a3) #> 1-element Array{Int64,1}: [1]
|
||||
#> 1-element Array{Int64,1}: [1]
|
||||
|
||||
push!(a6, [1,2,3])
|
||||
printsum(a6)
|
||||
#> 1-element Array{Array{Int64,1},1}: Array{Int64,1}[[1, 2, 3]]
|
||||
|
||||
# using repeat() to create arrays
|
||||
# you must use the keywords "inner" and "outer"
|
||||
# all arguments must be arrays (not ranges)
|
||||
a7 = repeat(a1,inner=[2],outer=[1])
|
||||
printsum(a7)
|
||||
#> 8-element Array{Int64,1}: [1, 1, 2, 2, 3, 3, 4, 4]
|
||||
a8 = repeat(collect(4:-1:1),inner=[1],outer=[2])
|
||||
printsum(a8)
|
||||
#> 8-element Array{Int64,1}: [4, 3, 2, 1, 4, 3, 2, 1]
|
||||
|
||||
# try, catch can be used to deal with errors as with many other languages
|
||||
try
|
||||
push!(a,1)
|
||||
catch err
|
||||
showerror(stdout, err, backtrace());println()
|
||||
end
|
||||
#> UndefVarError: a not defined
|
||||
#> Stacktrace:
|
||||
#> [1] top-level scope at C:\JuliaByExample\src\error_handling.jl:5
|
||||
#> [2] include at .\boot.jl:317 [inlined]
|
||||
#> [3] include_relative(::Module, ::String) at .\loading.jl:1038
|
||||
#> [4] include(::Module, ::String) at .\sysimg.jl:29
|
||||
#> [5] exec_options(::Base.JLOptions) at .\client.jl:229
|
||||
#> [6] _start() at .\client.jl:421
|
||||
println("Continuing after error")
|
||||
#> Continuing after error
|
||||
|
||||
# repeat can be useful to expand a grid
|
||||
# as in R's expand.grid() function:
|
||||
|
||||
m1 = hcat(repeat([1,2],inner=[1],outer=[3*2]),
|
||||
repeat([1,2,3],inner=[2],outer=[2]),
|
||||
repeat([1,2,3,4],inner=[3],outer=[1]))
|
||||
printsum(m1)
|
||||
#> 12×3 Array{Int64,2}: [1 1 1; 2 1 1; 1 2 1; 2 2 2; 1 3 2; 2 3 2; 1 1 3; 2 1 3;
|
||||
#> 1 2 3; 2 2 4; 1 3 4; 2 3 4]
|
||||
|
||||
# for simple repetitions of arrays,
|
||||
# use repeat
|
||||
m2 = repeat(m1,1,2) # replicate a9 once into dim1 and twice into dim2
|
||||
println("size: ", size(m2))
|
||||
#> size: (12, 6)
|
||||
|
||||
m3 = repeat(m1,2,1) # replicate a9 twice into dim1 and once into dim2
|
||||
println("size: ", size(m3))
|
||||
#> size: (24, 3)
|
||||
|
||||
# Julia comprehensions are another way to easily create
|
||||
# multidimensional arrays
|
||||
|
||||
m4 = [i+j+k for i=1:2, j=1:3, k=1:2] # creates a 2x3x2 array of Int64
|
||||
m5 = ["Hi Im # $(i+2*(j-1 + 3*(k-1)))" for i=1:2, j=1:3, k=1:2]
|
||||
# expressions are very flexible
|
||||
# you can specify the type of the array by just
|
||||
# placing it in front of the expression
|
||||
|
||||
import LegacyStrings
|
||||
m5 = LegacyStrings.ASCIIString["Hi Im element # $(i+2*(j-1 + 3*(k-1)))" for i=1:2, j=1:3, k=1:2]
|
||||
printsum(m5)
|
||||
#> 2×3×2 Array{LegacyStrings.ASCIIString,3}: LegacyStrings.ASCIIString[
|
||||
#> "Hi Im element # 1" "Hi Im element # 3" "Hi Im element # 5";
|
||||
#> "Hi Im element # 2" "Hi Im element # 4" "Hi Im element # 6"]
|
||||
#>
|
||||
#> LegacyStrings.ASCIIString["Hi Im element # 7" "Hi Im element # 9"
|
||||
#> "Hi Im element # 11"; "Hi Im element # 8" "Hi Im element # 10" "Hi Im element # 12"]
|
||||
|
||||
# Array reductions
|
||||
# many functions in Julia have an array method
|
||||
# to be applied to specific dimensions of an array:
|
||||
|
||||
sum(m4, dims=3) # takes the sum over the third dimension
|
||||
sum(m4, dims=(1,3)) # sum over first and third dim
|
||||
|
||||
maximum(m4, dims=2) # find the max elt along dim 2
|
||||
findmax(m4, dims=3) # find the max elt and its index along dim 3
|
||||
# (available only in very recent Julia versions)
|
||||
|
||||
# Broadcasting
|
||||
# when you combine arrays of different sizes in an operation,
|
||||
# an attempt is made to "spread" or "broadcast" the smaller array
|
||||
# so that the sizes match up. broadcast operators are preceded by a dot:
|
||||
|
||||
m4 .+ 3 # add 3 to all elements
|
||||
m4 .+ [1,2] # adds vector [1,2] to all elements along first dim
|
||||
|
||||
# slices and views
|
||||
m4=m4[:,:,1] # holds dim 3 fixed
|
||||
m4[:,2,:] # that's a 2x1x2 array. not very intuititive to look at
|
||||
|
||||
# get rid of dimensions with size 1:
|
||||
dropdims(m4[:,2,:], dims=2) # that's better
|
||||
|
||||
# assign new values to a certain view
|
||||
m4[:,:,1] = rand(1:6,2,3)
|
||||
printsum(m4)
|
||||
#> 2×3 Array{Int64,2}: [3 5 3; 1 3 5]
|
||||
|
||||
# (for more examples of try, catch see Error Handling above)
|
||||
try
|
||||
# this will cause an error, you have to assign the correct type
|
||||
m4[:,:,1] = rand(2,3)
|
||||
catch err
|
||||
println(err)
|
||||
end
|
||||
#> InexactError(:Int64, Int64, 0.7603891754678744)
|
||||
|
||||
try
|
||||
# this will cause an error, you have to assign the right shape
|
||||
m4[:,:,1] = rand(1:6,3,2)
|
||||
catch err
|
||||
println(err)
|
||||
end
|
||||
#> DimensionMismatch("tried to assign 3×2 array to 2×3×1 destination")
|
||||
|
||||
# dicts can be initialised directly:
|
||||
a1 = Dict(1=>"one", 2=>"two")
|
||||
printsum(a1)
|
||||
#> Dict{Int64,String} with 2 entries: Dict(2=>"two",1=>"one")
|
||||
|
||||
# then added to:
|
||||
a1[3]="three"
|
||||
printsum(a1)
|
||||
#> Dict{Int64,String} with 3 entries: Dict(2=>"two",3=>"three",1=>"one")
|
||||
# (note dicts cannot be assumed to keep their original order)
|
||||
|
||||
# dicts may also be created with the type explicitly set
|
||||
a2 = Dict{Int64, AbstractString}()
|
||||
a2[0]="zero"
|
||||
printsum(a2)
|
||||
#> Dict{Int64,AbstractString} with 1 entry: Dict{Int64,AbstractString}(0=>"zero")
|
||||
|
||||
# dicts, like arrays, may also be created from comprehensions
|
||||
using Printf
|
||||
a3 = Dict([i => @sprintf("%d", i) for i = 1:10])
|
||||
printsum(a3)
|
||||
#> Dict{Int64,String} with 10 entries: Dict(7=>"7",4=>"4",9=>"9",10=>"10",
|
||||
#> 2=>"2",3=>"3",5=>"5",8=>"8",6=>"6",1=>"1")
|
||||
|
||||
# as you would expect, Julia comes with all the normal helper functions
|
||||
# for dicts, e.g., haskey
|
||||
println(haskey(a1,1)) #> true
|
||||
|
||||
# which is equivalent to
|
||||
println(1 in keys(a1)) #> true
|
||||
# where keys creates an iterator over the keys of the dictionary
|
||||
|
||||
# similar to keys, values get iterators over the dict's values:
|
||||
printsum(values(a1))
|
||||
#> Base.ValueIterator for a Dict{Int64,String} with 3 entries: ["two", "three", "one"]
|
||||
|
||||
# use collect to get an array:
|
||||
printsum(collect(values(a1)))
|
||||
#> 3-element Array{String,1}: ["two", "three", "one"]
|
||||
|
||||
if true
|
||||
println("It's true!")
|
||||
else
|
||||
println("It's false!")
|
||||
end
|
||||
#> It's true!
|
||||
|
||||
if false
|
||||
println("It's true!")
|
||||
else
|
||||
println("It's false!")
|
||||
end
|
||||
#> It's false!
|
||||
|
||||
# Numbers can be compared with opperators like <, >, ==, !=
|
||||
|
||||
1 == 1.
|
||||
#> true
|
||||
|
||||
1 > 2
|
||||
#> false
|
||||
|
||||
"foo" != "bar"
|
||||
#> true
|
||||
|
||||
# and many functions return boolean values
|
||||
|
||||
occursin("that", "this and that")
|
||||
#> true
|
||||
|
||||
# More complex logical statments can be achieved with `elseif`
|
||||
|
||||
function checktype(x)
|
||||
if x isa Int
|
||||
println("Look! An Int!")
|
||||
elseif x isa AbstractFloat
|
||||
println("Look! A Float!")
|
||||
elseif x isa Complex
|
||||
println("Whoa, that's complex!")
|
||||
else
|
||||
println("I have no idea what that is")
|
||||
end
|
||||
end
|
||||
|
||||
checktype(2)
|
||||
#> Look! An Int!
|
||||
|
||||
checktype(√2)
|
||||
#> Look! A Float!
|
||||
|
||||
checktype(√Complex(-2))
|
||||
#> Whoa, that's complex!
|
||||
|
||||
checktype("who am I?")
|
||||
#> I have no idea what that is
|
||||
|
||||
# For simple logical statements, one can be more terse using the "ternary operator",
|
||||
# which takes the form `predicate ? do_if_true : do_if_false`
|
||||
|
||||
1 > 2 ? println("that's true!") : println("that's false!")
|
||||
#> that's false!
|
||||
|
||||
noisy_sqrt(x) = x ≥ 0 ? sqrt(x) : "That's negative!"
|
||||
noisy_sqrt(4)
|
||||
#> 2.0
|
||||
noisy_sqrt(-4)
|
||||
#> That's negative!
|
||||
|
||||
# "Short-circuit evaluation" offers another option for conditional statements.
|
||||
# The opperators `&&` for AND and `||` for OR only evaluate the right-hand
|
||||
# statement if necessary based on the predicate.
|
||||
# Logically, if I want to know if `42 == 0 AND x < y`,
|
||||
# it doesn't matter what `x` and `y` are, since the first statement is false.
|
||||
# This can be exploited to only evaluate a statement if something is true -
|
||||
# the second statement doesn't even have to be boolean!
|
||||
|
||||
everything = 42
|
||||
everything < 100 && println("that's true!")
|
||||
#> "that's true!"
|
||||
everything == 0 && println("that's true!")
|
||||
#> false
|
||||
|
||||
√everything > 0 || println("that's false!")
|
||||
#> true
|
||||
√everything == everything || println("that's false!")
|
||||
#> that's false!
|
||||
|
||||
Loading…
Reference in New Issue
Block a user