private static Func <SyntaxNode, Scope, SyntaxNode> EventDeclaration(IEnumerable <SyntaxToken> args)
{
return((node, scope) =>
{
EventFieldDeclarationSyntax @event = (EventFieldDeclarationSyntax)node;
ParameterListSyntax @params = CSharp.ParseParameterList(RoslynCompiler.TokensToString(args));
var variable = @event
.Declaration
.Variables[0];
var delegateName = variable.Identifier.ToString() + "_delegate"; //td: unique ids
var delegateDecl = CSharp.DelegateDeclaration(RoslynCompiler.@void, delegateName)
.WithParameterList(@params)
.WithModifiers(@event.Modifiers);
//add the delegate
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
document.change(@event.Parent, RoslynCompiler.AddMember(delegateDecl));
return @event
.WithDeclaration(@event.Declaration
.WithType(CSharp.ParseTypeName(delegateName)));
});
}
private IEnumerable <SyntaxToken> myExtLexical(IEnumerable <SyntaxToken> tokens, Scope scope, LexicalExtension <SyntaxToken> extension)
{
string testResult = "my_ext_replaced "
+ RoslynCompiler.TokensToString(extension.Arguments)
+ " = "
+ RoslynCompiler.TokensToString(extension.Body);
return(RoslynCompiler.ParseTokens(testResult));
}
public ParserRuleContext parse(IEnumerable <SyntaxToken> tokens, Scope scope, int offset)
{
var text = RoslynCompiler.TokensToString(tokens);
AntlrInputStream stream = new AntlrInputStream(text);
ITokenSource lexer = new RLexer(stream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
RParser parser = new RParser(tokenStream);
return(parser.prog());
}
public ParserRuleContext parse(IEnumerable <SyntaxToken> tokens, Scope scope, int offset)
{
var text = RoslynCompiler.TokensToString(tokens);
AntlrInputStream stream = new AntlrInputStream(text);
ITokenSource lexer = new JSONLexer(stream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
JSONParser parser = new JSONParser(tokenStream);
parser.AddErrorListener(new AntlrErrors <IToken>(scope, offset));
var result = parser.json();
if (parser.NumberOfSyntaxErrors > 0)
{
return(null);
}
return(result);
}
public ParserRuleContext Parse(LexicalExtension <SyntaxToken> extension, Scope scope)
{
var text = RoslynCompiler.TokensToString(extension.Body); //td: token matching
AntlrInputStream stream = new AntlrInputStream(text);
ITokenSource lexer = GetLexer(stream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
Parser parser = GetParser(tokenStream);
parser.AddErrorListener(new AntlrErrors <IToken>(scope, extension.BodyStart));
var result = GetRoot(parser);
if (parser.NumberOfSyntaxErrors > 0)
{
return(null);
}
return(result);
}
private SyntaxNode myExtSyntactical(SyntaxNode node, Scope scope, LexicalExtension <SyntaxToken> extension)
{
Assert.IsTrue(node is MethodDeclarationSyntax);
var method = node as MethodDeclarationSyntax;
Assert.IsTrue(method.Identifier.ToString() == "__extension");
var argString = RoslynCompiler.TokensToString(extension.Arguments);
Assert.IsTrue(argString == "(int i) ");
var arguments = CSharp.ParseParameterList(argString);
var codeString = RoslynCompiler.TokensToString(extension.Body);
var codeNode = CSharp.ParseStatement(codeString);
Assert.IsTrue(codeNode is BlockSyntax);
var code = codeNode as BlockSyntax;
return(method
.WithIdentifier(CSharp.ParseToken("my_ext_s"))
.WithParameterList(arguments)
.WithBody(code));
}
