Esempio n. 1
0
        private static IEnumerable <StatementSyntax> ExplodeStatements(SyntaxList <StatementSyntax> statements, SyntaxNode toReplace, BlockSyntax block)
        {
            var nodeID = RoslynCompiler.NodeMark(toReplace);

            foreach (var statement in statements)
            {
                var innerID = RoslynCompiler.NodeMark(statement);
                if (innerID == nodeID)
                {
                    foreach (var inner in block.Statements)
                    {
                        yield return(inner);
                    }
                }
                else
                {
                    yield return(statement);
                }
            }
        }
Esempio n. 2
0
        private ExcessDocument loadDocument(Project project, string fileName, out RoslynCompiler compiler)
        {
            if (_extensions == null || !_extensions.Any())
            {
                throw new InvalidOperationException("no extensions registered, plain c#?");
            }

            var source   = File.ReadAllText(fileName);
            var document = new RoslynDocument(new Scope(_scope), source, fileName);

            var enviroment     = new RoslynEnvironment(_scope, new SolutionStorage(project));
            var compilerResult = new RoslynCompiler(enviroment, _scope);
            var tree           = CSharpSyntaxTree.ParseText(source);
            var usings         = (tree.GetRoot() as CompilationUnitSyntax)
                                 ?.Usings
                                 .Where(@using =>
            {
                var usingId = @using.Name.ToString();
                if (!usingId.StartsWith("xs."))
                {
                    return(false);
                }

                usingId = usingId.Substring("xs.".Length);

                var action = null as ExtensionFunc;
                if (_extensions.TryGetValue(usingId, out action))
                {
                    action(compilerResult, null);     //td: props?
                    return(true);
                }

                return(false);
            })
                                 .ToArray();

            compiler = compilerResult;
            return(document);
        }
Esempio n. 3
0
        public int GetExcessId(SyntaxToken token)
        {
            string xsStr = RoslynCompiler.TokenMark(token);

            return(xsStr == null ? -1 : int.Parse(xsStr));
        }
Esempio n. 4
0
 public SyntaxNode MarkNode(SyntaxNode node)
 {
     return(RoslynCompiler.MarkNode(node, RoslynCompiler.uniqueId())); //td: scope ids
 }
Esempio n. 5
0
 public static Func <SyntaxNode, Scope, SyntaxNode> ReplaceNode(SyntaxNode newNode)
 {
     return((node, scope) => RoslynCompiler.ReplaceExcessId(newNode, node));
 }
Esempio n. 6
0
 public SyntaxToken InitToken(SyntaxToken token, int xsId)
 {
     return(RoslynCompiler.MarkToken(token, xsId.ToString()));
 }
Esempio n. 7
0
        public SyntaxToken MarkToken(SyntaxToken token)
        {
            string strId = RoslynCompiler.uniqueId();

            return(RoslynCompiler.MarkToken(token, strId));
        }
Esempio n. 8
0
 public string TokenToString(SyntaxToken token, out string xsId)
 {
     xsId = RoslynCompiler.TokenMark(token);
     return(token.ToFullString());
 }
Esempio n. 9
0
 public bool isIdentifier(SyntaxToken token)
 {
     return(RoslynCompiler.isLexicalIdentifier(token.Kind()));
 }
Esempio n. 10
0
 public string GetExcessStringId(SyntaxNode node)
 {
     return(RoslynCompiler.NodeMark(node));
 }
Esempio n. 11
0
        public int GetExcessId(SyntaxNode node)
        {
            string xsStr = RoslynCompiler.NodeMark(node);

            return(xsStr == null ? -1 : int.Parse(xsStr));
        }
Esempio n. 12
0
        //rewriters
        private Func <SyntaxNode, Scope, LookAheadResult> CheckCodeExtension(SyntaxNode original, SyntacticalExtension <SyntaxNode> extension)
        {
            return((node, scope) =>
            {
                var code = node as BlockSyntax;
                if (code == null)
                {
                    return new LookAheadResult {
                        Matched = false
                    }
                }
                ;

                _lookahead = null;
                extension.Body = base.Visit(code);

                SyntaxNode resulSyntaxNode = null;

                if (original is LocalDeclarationStatementSyntax)
                {
                    extension.Kind = ExtensionKind.Expression;

                    resulSyntaxNode = extension.Handler(node, scope, extension);
                    if (!(resulSyntaxNode is ExpressionSyntax))
                    {
                        //td: error, expecting expression
                        return new LookAheadResult {
                            Matched = false
                        };
                    }

                    var localDecl = original as LocalDeclarationStatementSyntax;
                    resulSyntaxNode = localDecl
                                      .WithDeclaration(localDecl.Declaration
                                                       .WithVariables(CSharp.SeparatedList(new[] {
                        localDecl.Declaration.Variables[0]
                        .WithInitializer(localDecl.Declaration.Variables[0].Initializer
                                         .WithValue((ExpressionSyntax)resulSyntaxNode))
                    })))
                                      .WithSemicolonToken(CSharp.ParseToken(";"));
                }
                else if (original is ExpressionStatementSyntax)
                {
                    var exprStatement = original as ExpressionStatementSyntax;
                    var assignment = exprStatement.Expression as AssignmentExpressionSyntax;
                    if (assignment != null)
                    {
                        extension.Kind = ExtensionKind.Expression;
                        resulSyntaxNode = extension.Handler(node, scope, extension);
                        if (!(resulSyntaxNode is ExpressionSyntax))
                        {
                            //td: error, expecting expression
                            return new LookAheadResult {
                                Matched = false
                            };
                        }

                        resulSyntaxNode = exprStatement
                                          .WithExpression(assignment
                                                          .WithRight((ExpressionSyntax)resulSyntaxNode))
                                          .WithSemicolonToken(CSharp.ParseToken(";"));
                    }
                    else
                    {
                        resulSyntaxNode = extension.Handler(node, scope, extension);
                        if (resulSyntaxNode != null)
                        {
                            resulSyntaxNode = RoslynCompiler.UpdateExcessId(resulSyntaxNode, node);
                        }
                    }
                }
                else
                {
                    throw new NotImplementedException();
                }

                return new LookAheadResult
                {
                    Matched = true,
                    Result = resulSyntaxNode,
                };
            });
        }
Esempio n. 13
0
        public void addDocument(string id, IDocument <SyntaxToken, SyntaxNode, SemanticModel> document, RoslynCompiler compiler)
        {
            if (_documents
                .Where(doc => doc.Id == id)
                .Any())
            {
                throw new InvalidOperationException($"duplicate file: {id}");
            }

            var newDoc = new CompilationDocument
            {
                Id       = id,
                Stage    = CompilerStage.Started,
                Document = document,
                Compiler = compiler,
            };

            //build the document
            var documentInjector = newDoc.Compiler as IDocumentInjector <SyntaxToken, SyntaxNode, SemanticModel>;

            documentInjector.apply(newDoc.Document);

            _documents.Add(newDoc);
        }