private int ProcessBracesState(CodeEditor editor, Region c, int endPos)
{
// get the lexer type of the body
string type = null;
switch (c[-1])
{
case '(':
// get preceding word from brace position
var wordStart = editor.WordStartPosition(c.Pos - 1, false);
type = editor.GetWordFromPosition(wordStart);
if (type != "layout")
type = "functionheader";
break;
case '{':
// get preceding non-whitespace position from brace position
var bracePos = c.Pos - 2;
while (bracePos >= 0
&& (char)editor.GetCharAt(bracePos) != ';'
&& char.IsWhiteSpace((char)editor.GetCharAt(bracePos)))
bracePos--;
// if the preceding char is a closing brace, we have to lex a function body
var braceChar = (char)editor.GetCharAt(bracePos);
type = braceChar == ')' ? "function" : "struct";
break;
case '}':
return -1;
default:
return ProcessDefaultState(editor, c);
}
// find lexer that can lex this code block
var lex = lexer.Where(x => x.IsLexerForType(type)).FirstOr(null);
// re-lex body of the uniform block, struct, layout or function
c.Pos = lex?.Style(editor, c.Pos, endPos) ?? c.Pos;
// continue styling from the last position
editor.StartStyling(c.Pos);
return ProcessDefaultState(editor, c);
}
public void Fold(CodeEditor editor, int pos, int endPos)
{
// setup state machine
var line = editor.LineFromPosition(pos);
var lastLine = -1;
var lastCharPos = line;
var foldLevel = editor.Lines[line].FoldLevel;
var textLength = editor.TextLength;
const int DEFAULT_FOLD_LEVEL = 1024;
// for each character
for (var state = FoldState.Unknown;
state == FoldState.Unknown ? pos < endPos : pos < textLength;
pos++)
{
var c = (char)editor.GetCharAt(pos);
switch (c)
{
// open folding
case '{':
state = FoldState.StartFolding;
break;
// close folding
case '}':
state = FoldState.EndFolding;
break;
// next line
case '\n':
line++;
break;
// remember last character to place
// fold icon in the last character line
default:
if (char.IsLetterOrDigit(c))
lastCharPos = pos;
break;
}
switch (state)
{
// STATE: open folding
case FoldState.StartFolding:
var lastCharLine = editor.LineFromPosition(lastCharPos);
// start folding at last character containing line
editor.Lines[lastCharLine].FoldLevelFlags = FoldLevelFlags.Header;
editor.Lines[lastCharLine].FoldLevel = foldLevel++;
// for all other lines up to the current position also add folding
for (int i = lastCharLine + 1; i <= line; i++)
{
editor.Lines[i].FoldLevelFlags = FoldLevelFlags.White;
editor.Lines[i].FoldLevel = foldLevel;
}
lastLine = line;
// switch to folding state
state = FoldState.Foldable;
break;
// STATE: close folding
case FoldState.EndFolding:
// end folding
editor.Lines[line].FoldLevel = foldLevel;
// decrease fold level
foldLevel = Math.Max(--foldLevel, DEFAULT_FOLD_LEVEL);
lastLine = line;
// switch to folding state (which will
// switch to unknown state if the most
// outer fold level is reached)
state = FoldState.Foldable;
break;
// STATE: folding
case FoldState.Foldable:
// still in folding state
if (foldLevel > DEFAULT_FOLD_LEVEL)
{
if (line != lastLine)
{
// set fold level for line
editor.Lines[line].FoldLevel = foldLevel;
lastLine = line;
}
}
// end folding state
else
state = FoldState.Unknown;
break;
}
}
}
/// <summary>
/// Default process new line state.
/// </summary>
/// <param name="editor"></param>
/// <param name="c"></param>
/// <returns>The new state after processing the current state.</returns>
protected int DefaultProcessNewLine(CodeEditor editor, Region c)
{
// exit lexer if line does not end with "..."
int i = c.Pos - 1;
var C = (char)editor.GetCharAt(i);
while (i > 0 && C != '\n' && char.IsWhiteSpace(C))
C = (char)editor.GetCharAt(--i);
return editor.GetTextRange(i - 2, 3) != "..." ? -1 : (int)BaseState.Default;
}
private int ProcessBraceState(CodeEditor editor, Region c)
{
// is a closing brace
if (c[-1] == '}')
{
int i, count, style;
// find matching brace position
for (i = c.Pos - 1, count = 0; i >= 0; i--)
{
switch (editor.GetCharAt(i))
{
case '{': count--; break;
case '}': count++; break;
}
if (count == 0) break;
}
// if no matching brace found, exit
if (count != 0 || i < 0)
return -1;
// go to first non base state before the matching brace position
for (style = editor.GetStyleAt(--i);
i >= 0 && firstBaseStyle <= style && style <= lastBaseStyle;
style = editor.GetStyleAt(--i))
{
var C = editor.GetCharAt(i);
if (C == '{' || C == '}')
break;
}
// if no function lexer state found, exit
if ((i < 0 || style < firstStyle || lastStyle < style) && style != BraceStyle)
return -1;
}
return ProcessDefaultState(editor, c);
}