static void Main(string[] args)
{
var lexer = new AphidLexer(@"
using System;
Console.WriteLine('Hello world');
");
foreach (var t in lexer.GetTokens())
{
Console.WriteLine(t);
}
}
public void AppendCode(Paragraph paragraph, string code)
{
code = code.Replace("\r\n", "\n").Replace("\r", "\n") + " ";
var tokens = new AphidLexer(code).GetAllTokens();
foreach (var t in tokens)
{
var run = new Run(t.Lexeme)
{
Foreground = new SolidColorBrush(GetColor(t.TokenType))
};
paragraph.Inlines.Add(run);
}
Document.Blocks.Add(paragraph);
ScrollToEnd();
}
public static List <AphidExpression> Parse(
string code,
string filename,
bool isTextDocument = false,
bool useImplicitReturns = true)
{
var lexer = new AphidLexer(code);
if (isTextDocument)
{
lexer.SetTextMode();
}
return(Parse(
lexer.GetTokens(),
code,
filename,
useImplicitReturns: useImplicitReturns));
}
public static AphidObject EvalExpression(AphidInterpreter interpreter, string code)
{
AphidObject result = null;
void action()
{
if (code.Trim()?.Length == 0)
{
return;
}
var lexer = new AphidLexer(code);
var tokens = lexer.GetTokens();
var exp = AphidParser.ParseExpression(tokens, code);
var retExp = new UnaryOperatorExpression(AphidTokenType.retKeyword, exp);
//new AphidCodeVisitor(code).VisitExpression(retExp);
interpreter.Interpret(retExp);
result = interpreter.GetReturnValue(true);
if (result != null && (result.Value != null || result.Any()))
{
WriteLineHighlighted(
SerializingFormatter.Format(
interpreter,
result,
ignoreNull: false,
ignoreClrObj: false));
}
}
if (AphidErrorHandling.HandleErrors)
{
TryAction(interpreter, code, action);
}
else
{
action();
}
return(result);
}
private static AphidExpression ParseCore(string expression)
{
var fixedExpression = expression;
List <AphidToken> tokens;
AphidToken lastToken = default;
int state, offset = 0;
do
{
tokens = AphidLexer.GetTokens(fixedExpression);
state = 0;
for (var i = 0; i < tokens.Count; i++)
{
lastToken = tokens[i];
if (lastToken.TokenType == _tickType)
{
offset = lastToken.Index;
fixedExpression = fixedExpression.Remove(offset, 1).Insert(offset, "'");
if (++state == 2)
{
break;
}
}
}
if (state == 1)
{
throw new AphidParserException(
$"Unterminated string beginning at {expression.Substring(offset)}")
{
UnexpectedToken = lastToken,
};
}
}while (state != 0);
return(AphidParser.ParseExpression(tokens, expression));
}
private void CheckParseRequest(ParseRequest req)
{
try
{
var lexer = new AphidLexer(req.Text);
var parser = new AphidParser(lexer.GetTokens());
parser.Parse();
}
catch (AphidParserException e)
{
var lineCol = TokenHelper.GetLineCol(req.Text, e.Token.Index);
var span = new TextSpan()
{
iStartLine = lineCol.Item1,
iEndLine = lineCol.Item1,
iStartIndex = lineCol.Item2,
iEndIndex = lineCol.Item2 + (e.Token.Lexeme != null ? e.Token.Lexeme.Length : 0)
};
var msg = string.Format("Unexpected {0}: {1}", e.Token.TokenType.ToString(), e.Token.Lexeme);
req.Sink.AddError(req.FileName, msg, span, Severity.Error);
}
}
public void SetSource(string source, int offset)
{
_index = 0;
try
{
var lexer = new AphidLexer(source);
if (_lexerMode != 0)
{
lexer.SetMode(_lexerMode);
}
_tokens = lexer
.GetAllTokens()
.Where(x => x.TokenType != WhiteSpace)
.ToArray();
_lexerMode = lexer.GetMode();
}
catch
{
_tokens = new AphidToken[0];
}
}
public static int[][] GetBraces(string text, int line, int col)
{
var index = Components.Aphid.VSPackage.TokenHelper.GetIndex(text, line, col);
var str = text.Substring(index);
var tokens = new AphidLexer(str).GetTokens();
var startBrace = tokens[0].TokenType;
AphidTokenType[] braces;
switch (tokens[0].TokenType)
{
case AphidTokenType.LeftBrace:
case AphidTokenType.RightBrace:
braces = new[] { AphidTokenType.LeftBrace, AphidTokenType.RightBrace };
break;
case AphidTokenType.LeftParenthesis:
case AphidTokenType.RightParenthesis:
braces = new[] { AphidTokenType.LeftParenthesis, AphidTokenType.RightParenthesis };
break;
case AphidTokenType.LeftBracket:
case AphidTokenType.RightBracket:
braces = new[] { AphidTokenType.LeftBracket, AphidTokenType.RightBracket };
break;
default:
throw new InvalidOperationException();
}
var depth = 1;
if (startBrace == braces[0])
{
var rightBraceIndex = -1;
for (int i = 1; i < tokens.Count; i++)
{
if (tokens[i].TokenType == braces[0])
{
depth++;
}
else if (tokens[i].TokenType == braces[1])
{
depth--;
}
if (depth == 0)
{
rightBraceIndex = index + tokens[i].Index;
break;
}
}
if (rightBraceIndex != -1)
{
var rightLineCol = Components.Aphid.VSPackage.TokenHelper.GetLineCol(text, rightBraceIndex);
return(new[]
{
new[] { line, col },
new[] { rightLineCol.Item1, rightLineCol.Item2 },
});
}
}
else if (startBrace == braces[1])
{
depth = -1;
var leftBraceIndex = -1;
str = text.Remove(index);
tokens = new AphidLexer(str).GetTokens();
for (int i = tokens.Count - 1; i >= 0; i--)
{
if (tokens[i].TokenType == braces[0])
{
depth++;
}
else if (tokens[i].TokenType == braces[1])
{
depth--;
}
if (depth == 0)
{
leftBraceIndex = tokens[i].Index;
break;
}
}
if (leftBraceIndex != -1)
{
var leftLineCol = Components.Aphid.VSPackage.TokenHelper.GetLineCol(text, leftBraceIndex);
return(new[]
{
new[] { leftLineCol.Item1, leftLineCol.Item2 },
new[] { line, col },
});
}
}
else
{
throw new InvalidOperationException();
}
return(null);
}
public override AuthoringScope ParseSource(ParseRequest req)
{
Debug.WriteLine("Parse reason: {0}", req.Reason);
var scope = new AphidAuthoringScope();
//scope.Identifiers = GetTokens(req.Text)
// .Where(x => x.TokenType == AphidTokenType.Identifier)
// .Select(x => x.Lexeme)
// .Distinct()
// .ToArray();
switch (req.Reason)
{
case ParseReason.QuickInfo:
break;
case ParseReason.MemberSelect:
break;
case ParseReason.DisplayMemberList:
break;
case ParseReason.CompleteWord:
break;
case ParseReason.MatchBraces:
case ParseReason.MemberSelectAndHighlightBraces:
case ParseReason.HighlightBraces:
var braces = TokenHelper.GetBraces(
req.Text,
req.Line,
req.Col - 1);
if (braces != null)
{
req.Sink.MatchPair(CreateSpan(braces[0][0], braces[0][1]), CreateSpan(braces[1][0], braces[1][1]), 1);
}
var index = TokenHelper.GetIndex(req.Text, req.Line, req.Col - 1);
var str = req.Text.Substring(index);
var tokens = new AphidLexer(str).GetAllTokens();
var depth = 1;
var rightBraceIndex = -1;
for (int i = 1; i < tokens.Count; i++)
{
switch (tokens[i].TokenType)
{
case AphidTokenType.LeftBrace:
depth++;
break;
case AphidTokenType.RightBrace:
depth--;
break;
}
if (depth == 0)
{
rightBraceIndex = index + tokens[i].Index;
break;
}
}
if (rightBraceIndex != -1)
{
var rightLineCol = TokenHelper.GetLineCol(req.Text, rightBraceIndex);
req.Sink.MatchPair(CreateSpan(req.Line, req.Col - 1), CreateSpan(rightLineCol.Item1, rightLineCol.Item2), 1);
}
break;
case ParseReason.Check:
CheckParseRequest(req);
break;
default:
break;
}
return(scope);
}
protected override void OnRender(DrawingContext drawingContext)
{
DebugHelper.Trace();
if (glyphFace == null)
{
return;
}
else if (string.IsNullOrEmpty(_text))
{
_currentColumn = 0;
_currentRow = 0;
MoveCaretToCurrentCell();
SetDefaultSize();
CreateDocument(new List <AphidToken>());
return;
}
var lexer = new AphidLexer(_text);
CreateDocument(lexer.GetAllTokens());
double greatestX = 0, greatestY = 0;
for (int y = 0; y < _document.Count; y++)
{
for (int x = 0; x < _document[y].Count; x++)
{
var cell = _document[y][x];
if (cell.Char == '\n')
{
continue;
}
var glyph = BuildGlyphRun(x, y, cell.Char);
drawingContext.DrawGlyphRun(
new SolidColorBrush(GetColor(cell.Type)),
glyph);
var x2 = glyph.BaselineOrigin.X + _cellWidth;
if (x2 > greatestX)
{
greatestX = x2;
}
if (glyph.BaselineOrigin.Y > greatestY)
{
//greatestY = glyph.BaselineOrigin.Y + 20;
greatestY = glyph.BaselineOrigin.Y;
}
}
}
var caretY = Canvas.GetTop(_caret) + _caret.Height;
if (caretY > greatestY)
{
greatestY = caretY;
}
Width = greatestX;
Height = greatestY;
}
private void ExecuteStatements()
{
ResetInterpreter();
InvokeDispatcher(() =>
{
_codeViewer.Document.Blocks.Clear();
_codeViewer.AppendOutput("Running script...");
});
if (string.IsNullOrEmpty(Code))
{
return;
}
var tokens = new AphidLexer(Code).GetTokens();
List <Components.Aphid.Parser.Expression> ast = null;
try
{
ast = new AphidParser(tokens).Parse();
}
catch (AphidParserException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendParserException(Code, ex));
return;
}
try
{
_interpreter.Interpret(ast);
}
catch (AphidRuntimeException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendException(Code, "Runtime error", ex));
return;
}
catch (AphidParserException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendParserException(Code, ex));
return;
}
catch (Exception ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendException(Code, "Internal error", ex));
}
UpdateVariables();
ExecuteWatchExpressions();
InvokeDispatcher(() =>
{
_codeViewer.AppendOutput("Done");
_codeViewer.ScrollToEnd();
});
}
private void ExecuteExpression()
{
if (string.IsNullOrEmpty(Code))
{
return;
}
AddHistoricalCode();
var tokens = new AphidLexer(Code + " ").GetTokens();
if (!tokens.Any(x => x.TokenType == AphidTokenType.EndOfStatement))
{
tokens.Add(new AphidToken(AphidTokenType.EndOfStatement, "", 0));
}
List <Components.Aphid.Parser.Expression> ast = null;
try
{
ast = new AphidParser(tokens).Parse();
}
catch (AphidParserException ex)
{
InvokeDispatcher(() => _codeViewer.AppendParserException(Code, ex));
return;
}
if (ast.Count != 1)
{
throw new InvalidOperationException();
}
var exp = ast.First();
var unary = exp as UnaryOperatorExpression;
if (unary == null ||
unary.Operator != AphidTokenType.retKeyword)
{
ast.Clear();
ast.Add(new UnaryOperatorExpression(
AphidTokenType.retKeyword,
exp));
}
try
{
_interpreter.Interpret(ast);
}
catch (AphidRuntimeException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendException(Code, "Runtime error", ex));
return;
}
catch (AphidParserException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendParserException(Code, ex));
return;
}
var retVal = _interpreter.GetReturnValue();
var serializer = new AphidSerializer()
{
IgnoreFunctions = false
};
InvokeDispatcher(() =>
_codeViewer.AppendOutput(Code, serializer.Serialize(retVal)));
UpdateVariables();
ExecuteWatchExpressions();
}
public static AphidExpression ParseExpression(string code) => ParseExpression(AphidLexer.GetTokens(code), code);
