Esempio n. 1
0
        private static void handleFunctionCall(Logic[] logicOrder, expectType theExpectedType, int lineNumber, Scope currentScope, int i)
        {
            FunctionParser.linkFunctionCall((logicOrder [i] as FunctionCall), lineNumber, currentScope);

            if ((logicOrder [i] as FunctionCall).targetFunc.isUserFunction)
            {
                currentScope.getCurrentLine().insertReturnExpect(logicOrder [i]);
                (logicOrder [i] as FunctionCall).runFunction(currentScope);

                throw new FunctionCallException();
            }
            else
            {
                if ((logicOrder [i] as FunctionCall).targetFunc.pauseWalker)
                {
                    CodeWalker.pauseWalker();
                }

                if ((logicOrder[i] as FunctionCall).targetFunc.name == "input")
                {
                    CodeWalker.linkSubmitInput.Invoke(SubmitInput, currentScope);

                    Variable returnVariable = (logicOrder[i] as FunctionCall).runFunction(currentScope);
                    logicOrder[i] = returnVariable;

                    if (returnVariable.variableType == VariableTypes.boolean)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
                    }
                    else if (returnVariable.variableType == VariableTypes.number)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber);
                    }
                    else if (returnVariable.variableType == VariableTypes.textString)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber);
                    }

                    CodeWalker.isWaitingForUserInput = true;
                }
                else
                {
                    Variable returnVariable = (logicOrder[i] as FunctionCall).runFunction(currentScope);
                    logicOrder[i] = returnVariable;

                    if (returnVariable.variableType == VariableTypes.boolean)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.boolean, lineNumber);
                    }
                    else if (returnVariable.variableType == VariableTypes.number)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.number, lineNumber);
                    }
                    else if (returnVariable.variableType == VariableTypes.textString)
                    {
                        setNewExpectVariable(theExpectedType, VariableTypes.textString, lineNumber);
                    }
                }
            }
        }
Esempio n. 2
0
 /// <summary>
 /// Walks through the code units in the query clause.
 /// </summary>
 /// <param name="statementCallback">
 /// Callback executed when a statement is visited.
 /// </param>
 /// <param name="expressionCallback">
 /// Callback executed when an expression is visited.
 /// </param>
 /// <param name="queryClauseCallback">
 /// Callback executed when a query clause is visited.
 /// </param>
 public void WalkQueryClause(
     CodeWalkerStatementVisitor <object> statementCallback,
     CodeWalkerExpressionVisitor <object> expressionCallback,
     CodeWalkerQueryClauseVisitor <object> queryClauseCallback)
 {
     Param.Ignore(statementCallback, expressionCallback, queryClauseCallback);
     CodeWalker <object> .Start(this, statementCallback, expressionCallback, queryClauseCallback, null);
 }
Esempio n. 3
0
 /// <summary>
 /// Walks through the code units in the query clause.
 /// </summary>
 /// <param name="statementCallback">
 /// Callback executed when a statement is visited.
 /// </param>
 /// <param name="expressionCallback">
 /// Callback executed when an expression is visited.
 /// </param>
 /// <param name="queryClauseCallback">
 /// Callback executed when a query clause is visited.
 /// </param>
 /// <param name="context">
 /// The optional visitor context data.
 /// </param>
 /// <typeparam name="T">
 /// The type of the context item.
 /// </typeparam>
 public void WalkQueryClause <T>(
     CodeWalkerStatementVisitor <T> statementCallback,
     CodeWalkerExpressionVisitor <T> expressionCallback,
     CodeWalkerQueryClauseVisitor <T> queryClauseCallback,
     T context)
 {
     Param.Ignore(statementCallback, expressionCallback, queryClauseCallback, context);
     CodeWalker <T> .Start(this, statementCallback, expressionCallback, queryClauseCallback, context);
 }
Esempio n. 4
0
        public static Logic parseContinueStatement(Logic[] logicOrder, int lineNumber, Scope currentScope)
        {
            //We use a shallow copy because we alter logicOrder in case of speciall operators
            Logic[] cloneLogicOrder = (Logic[])logicOrder.Clone();
            if (cloneLogicOrder.Length != 1 || cloneLogicOrder[0].currentType != WordTypes.continueStatement)
            {
                return(new UnknownLogic(lineNumber));
            }

            CodeWalker.continueLoop(findParentLoop(currentScope, lineNumber), lineNumber);
            return(new Variable());
        }
Esempio n. 5
0
        static async Task Main(string[] args)
        {
            // Attempt to set the version of MSBuild.
            var visualStudioInstances = MSBuildLocator.QueryVisualStudioInstances().ToArray();
            var instance = visualStudioInstances.Length == 1
                           // If there is only one instance of MSBuild on this machine, set that as the one to use.
                ? visualStudioInstances[0]
                           // Handle selecting the version of MSBuild you want to use.
                : SelectVisualStudioInstance(visualStudioInstances);

            Console.WriteLine($"Using MSBuild at '{instance.MSBuildPath}' to load projects.");

            // NOTE: Be sure to register an instance with the MSBuildLocator
            //       before calling MSBuildWorkspace.Create()
            //       otherwise, MSBuildWorkspace won't MEF compose.
            MSBuildLocator.RegisterInstance(instance);

            using (var workspace = MSBuildWorkspace.Create())
            {
                // Print message for WorkspaceFailed event to help diagnosing project load failures.
                workspace.WorkspaceFailed += (o, e) => Console.WriteLine(e.Diagnostic.Message);

                var solutionPath = args[0];
                Console.WriteLine($"Loading solution '{solutionPath}'");

                // Attach progress reporter so we print projects as they are loaded.
                var solution = await workspace.OpenSolutionAsync(solutionPath, new ConsoleProgressReporter());

                var solutionName = Path.GetFileNameWithoutExtension(solutionPath);

                Console.WriteLine($"Finished loading solution '{solutionPath}'");

                var nodes = new Dictionary <long, Node>();
                var edges = new Dictionary <long, EdgeNode>();

                foreach (var project in solution.Projects.Where(p => !p.Name.Contains("Test")))
                {
                    foreach (var document in project.Documents)//.Where(d=>!d.Name.Contains("Dummy")))
                    {
                        var        collector = new CodeWalker(document.FilePath, document.Name, nodes, edges);
                        SyntaxTree tree      = CSharpSyntaxTree.ParseText(await document.GetTextAsync());
                        var        root      = (CompilationUnitSyntax)tree.GetRoot();
                        collector.Visit(root);
                    }
                }
                // Save Data files
                new Exporter(nodes, edges)
                //.ExportJson(solutionName)
                //.ExportNeo4J(solutionName)
                .ExportCsv(solutionName);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Private helper function for all parsing.  Takes in the IronPython Parser
        /// object and a filename that's used for error reports
        /// </summary>
        /// <param name="p"></param>
        private CodeCompileUnit Parse(Parser p, string filename)
        {
            Stmt            s   = p.ParseFileInput();
            CodeCompileUnit res = new CodeCompileUnit();
            CodeNamespace   defaultNamespace = new CodeNamespace();

            //!!! enable AD usage when we're strong named.
            //AppDomainSetup ads = new AppDomainSetup();
            //ads.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            //AppDomain ad = AppDomain.CreateDomain("ParserReferenceDomain",null,ads);
            try {
                RemoteReferences rc = new RemoteReferences();

                /*(RemoteReferences)ad.CreateInstanceAndUnwrap(
                 *              Assembly.GetExecutingAssembly().FullName,
                 *              "IronPython.CodeDom.RemoteReferences");*/
                rc.Initialize(references);


                CodeWalker cw = new CodeWalker(filename, rc);
                s.Walk(cw);

                CodeObject      co  = cw.LastObject;
                CodeObjectSuite cos = co as CodeObjectSuite;
                if (cos == null)
                {
                    cos = new CodeObjectSuite(new CodeObject[] { co });
                }

                // walk the top-level and see if we need to create a fake top-type
                // or if we can just stick everything directly into the namespace.
                CodeTypeDeclaration topType = null;
                for (int i = 0; i < cos.Count; i++)
                {
                    topType = CheckTopLevel(cos[i], res, defaultNamespace, topType);
                }

                // if no namespaces we're added then everything's in our default namespace.
                if (res.Namespaces.Count == 0)
                {
                    res.Namespaces.Add(defaultNamespace);
                }

                UpdateTopType(topType, defaultNamespace);
            } finally {
                //AppDomain.Unload(ad);
            }

            return(res);
        }
Esempio n. 7
0
        public static void SubmitInput(string inputFromUser, Scope currentScope)
        {
            if (!CodeWalker.isWaitingForUserInput)
            {
                return;
            }

            CodeWalker.isWaitingForUserInput = false;

            var oldLine       = currentScope.getCurrentLine().cloneLine();
            var oldLineString = oldLine.getFullLine();
            var newLine       = ReplaceInputWithValue(oldLineString, inputFromUser);

            var lines = SyntaxCheck.parseLines(newLine);
            var words = lines.First().words;
            var logic = WordsToLogicParser.determineLogicFromWords(words, 1, currentScope);

            currentScope.getCurrentLine().words      = words;
            currentScope.getCurrentLine().logicOrder = logic;

            CodeWalker.parseLine(currentScope.getCurrentLine(), oldLine);
        }
        /// <summary>
        /// Renders the C# code text to the specified <see cref="TextWriter" />.
        /// </summary>
        /// <remarks>
        /// The version of the <c>Render</c> method does all of the work because the other versions ultimately call this one. The
        /// steps involved are:
        /// <list type="number">
        /// <item><description>
        ///     The code text is parsed to produce a <c>SyntaxTree</c>
        /// </description></item>
        /// <item><description>
        ///     A compilation unit is created from the <c>SyntaxTree</c> and <c>MetadataReferences</c> properties and from that
        ///     the <c>SemanticModel</c> is initialized. Note that renderers that are only interested in the syntax need not
        ///     access the semantic mode, but the HTML renderer does need this information to determine if an identifier represents
        ///     a symbol that should be (color) formatted.
        /// </description></item>
        /// <item><description>
        ///     The <c>SyntaxVisiting</c> event is handled by invoking the <c>Callback</c> passing the <c>SyntaxTreeElement</c>
        ///     object and <c>VisitingState</c> enumeration value encapsulated in the <c>SyntaxVisitingEventArgs</c> object.
        ///     Concrete implementations due the actual rendering from the callback delegate.
        /// </description></item>
        /// <item><description>
        ///     Any prefix text is recovered using the <c>GetPrefixText</c> method and is written to the <c>Writer</c>.
        /// </description></item>
        /// <item><description>
        ///     The syntax tree root node is passed to the <c>SyntaxWalker.Visit</c> method (really the overridden
        ///     <c>SyntaxVisitor.Visit</c> method. This causes the callback delegate to be called as the tree is traversed. From
        ///     the callback delegate, concrete implementations can write to the <c>Writer</c> to render the nodes, tokens and
        ///     trivia that make up the syntax tree.
        /// </description></item>
        /// <item><description>
        ///     Finally, any postfix text is recovered using the <c>GetPostfixText</c> method and is written to the <c>Writer</c>.
        /// </description></item>
        /// </list>
        /// </remarks>
        /// <param name="writer">The <c>TextWriter</c> which contains the rendered code. It is the responsibility of the
        /// caller to dispose of the <paramref name="writer" /> when it is no longer needed. </param>
        /// <param name="codeText">The code text as a <see cref="string" /> instance.</param>
        /// <exception cref="ArgumentNullException">if <paramref name="writer"/> is null.</exception>
        public virtual void Render(TextWriter writer, string codeText)
        {
            if (writer == null)
            {
                throw new ArgumentNullException(nameof(writer), "A non-null TextWriter is required.");
            }

            Writer     = writer;
            SyntaxTree = CSharpSyntaxTree.ParseText(codeText ?? string.Empty);

            // TODO: Formatting no longer provides a extension method on nodes. Move the entire functionality to another namespace.
            // if (FormatCode)
            // {
            //     IFormattingResult formattingResult = SyntaxTree.GetRoot().Format(FormattingOptions.GetDefaultOptions());
            //     CompilationUnitSyntax formattedRoot = (CompilationUnitSyntax)formattingResult.GetFormattedRoot();
            //     SyntaxTree = SyntaxTree.Create(formattedRoot);
            // }
            Compilation compilation = CSharpCompilation.Create("CoreRenderer",
                                                               syntaxTrees: new List <SyntaxTree> {
                SyntaxTree
            },
                                                               references: MetadataReferences);

            SemanticModel = compilation.GetSemanticModel(SyntaxTree);

            CodeWalker walker = new CodeWalker();

            walker.SyntaxVisiting += (s, e) =>
            {
                if (Callback != null)
                {
                    Callback(e.SyntaxTreeElement, e.State);
                }
            };

            Writer.Write(GetPrefixText());
            walker.Visit(SyntaxTree.GetRoot());
            Writer.Write(GetPostfixText());
        }
        public static Logic parseReturnStatement(Logic[] logicOrder, int lineNumber, Scope currentScope)
        {
            if (logicOrder.Length <= 1)
            {
            }

            Variable returnSum;

            if (logicOrder.Length <= 1)
            {
                // Should return None if there is no sum to return
                returnSum = new Variable();

                //This error should not exist
                ErrorMessage.sendErrorMessage(lineNumber, "I detta moment måste du returnera något ur funktionen");
            }
            else
            {
                Logic[] followOrder = InternalParseFunctions.getSubArray(logicOrder, 1, logicOrder.Length - 1, lineNumber);
                returnSum = SumParser.parseIntoSum(followOrder, lineNumber, currentScope);
            }

            ReturnStatement theReturn = (logicOrder [0] as ReturnStatement);

            theReturn.findFunctionParent(currentScope, lineNumber);

            CodeLine parentLine = theReturn.FunctionParent.parentScope.codeLines [theReturn.FunctionParent.parentScope.lastReadLine];

            ReturnMemoryControll.insertReturnValue(parentLine, lineNumber, returnSum);


            currentScope.isReturning = true;
            CodeWalker.setReturnTarget(theReturn.FunctionParent.parentScope);

            return(logicOrder [0] as ReturnStatement);
        }
Esempio n. 10
0
        public LoopUnrollingResults Unroll()
        {
            var unrolled = new DILOperationSet();
            //if (IsClearanceLoop())
            //{
            //    unrolled.Add(new AssignOp(0, 0));
            //    return new LoopUnrollingResults(unrolled, true);
            //}

            var withUnrolledNestLoops = new DILOperationSet();
            foreach (var instruction in Instructions)
            {
                if (instruction is LoopOp)
                {
                    var nestedLoop = instruction as LoopOp;
                    var ur = nestedLoop.Unroll();
                    if (ur.WasLoopUnrolled)
                    {
                        withUnrolledNestLoops.AddRange(ur.UnrolledInstructions);
                    } else
                    {
                        withUnrolledNestLoops.Add(new LoopOp(ur.UnrolledInstructions));
                    }
                }
                else
                {
                    withUnrolledNestLoops.Add(instruction);
                }
            }

            if (IsSimple(withUnrolledNestLoops))
            {
                var walk = new CodeWalker().Walk(withUnrolledNestLoops);
                if (walk.Domain.ContainsKey(0) && walk.Domain[0] == -1)
                {
                    foreach (var cell in walk.Domain)
                    {
                        if (cell.Key == 0)
                        {
                            continue;
                        }

                        //// If the scalar value of the multiplication operation is 0,
                        //// then simply assign 0 to the cell because n * 0 = 0.
                        //if (cell.Value == 0)
                        //{
                        //    unrolled.Add(new AssignOp(cell.Key, 0));
                        //}
                        //else
                        //{
                            unrolled.Add(new MultiplicationMemoryOp(cell.Key, cell.Value));
                        //}
                    }

                    // If it's a simple loop, then the cell position of the loop should always be assigned a 0 since that's when the loop stops.
                    if (walk.Domain.ContainsKey(0))
                    {
                        unrolled.Add(new AssignOp(0, 0));
                    }

                    return new LoopUnrollingResults(unrolled, true);
                } else
                {
                    return new LoopUnrollingResults(withUnrolledNestLoops, false);

                }
            }

            return new LoopUnrollingResults(withUnrolledNestLoops, false);
        }
Esempio n. 11
0
        /// <summary>
        /// Private helper function for all parsing.  Takes in the IronPython Parser 
        /// object and a filename that's used for error reports
        /// </summary>
        /// <param name="p"></param>
        private CodeCompileUnit Parse(Parser p, string filename)
        {
            Statement s = p.ParseFileInput();
            CodeCompileUnit res = new CodeCompileUnit();
            CodeNamespace defaultNamespace = new CodeNamespace();
            defaultNamespace.UserData["Line"] = 1;
            defaultNamespace.UserData["Column"] = 1;
            defaultNamespace.UserData["EndLine"] = 1;
            defaultNamespace.UserData["EndColumn"] = 1;

            //!!! enable AD usage when we're strong named.
            //AppDomainSetup ads = new AppDomainSetup();
            //ads.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            //AppDomain ad = AppDomain.CreateDomain("ParserReferenceDomain",null,ads);
            try {
                RemoteReferences rc = new RemoteReferences();
                /*(RemoteReferences)ad.CreateInstanceAndUnwrap(
                                Assembly.GetExecutingAssembly().FullName,
                                "IronPython.CodeDom.RemoteReferences");*/
                rc.Initialize(references);

                CodeWalker cw = new CodeWalker(filename, rc);
                s.Walk(cw);

                CodeObject co = cw.LastObject;
                CodeObjectSuite cos = co as CodeObjectSuite;
                if (cos == null) cos = new CodeObjectSuite(new CodeObject[] { co });

                // walk the top-level and see if we need to create a fake top-type
                // or if we can just stick everything directly into the namespace.
                CodeTypeDeclaration topType = null;
                for (int i = 0; i < cos.Count; i++) {
                    topType = CheckTopLevel(cos[i], res, defaultNamespace, topType);
                }

                // if no namespaces we're added then everything's in our default namespace.
                if (res.Namespaces.Count == 0 || defaultNamespace.Types.Count > 0) {
                    res.Namespaces.Add(defaultNamespace);
                }

                UpdateTopType(topType, defaultNamespace);
            } finally {
                //AppDomain.Unload(ad);
            }

            return res;
        }
Esempio n. 12
0
        public LoopUnrollingResults Unroll()
        {
            var unrolled = new DILOperationSet();
            //if (IsClearanceLoop())
            //{
            //    unrolled.Add(new AssignOp(0, 0));
            //    return new LoopUnrollingResults(unrolled, true);
            //}

            var withUnrolledNestLoops = new DILOperationSet();

            foreach (var instruction in Instructions)
            {
                if (instruction is LoopOp)
                {
                    var nestedLoop = instruction as LoopOp;
                    var ur         = nestedLoop.Unroll();
                    if (ur.WasLoopUnrolled)
                    {
                        withUnrolledNestLoops.AddRange(ur.UnrolledInstructions);
                    }
                    else
                    {
                        withUnrolledNestLoops.Add(new LoopOp(ur.UnrolledInstructions));
                    }
                }
                else
                {
                    withUnrolledNestLoops.Add(instruction);
                }
            }

            if (IsSimple(withUnrolledNestLoops))
            {
                var walk = new CodeWalker().Walk(withUnrolledNestLoops);
                if (walk.Domain.ContainsKey(0) && walk.Domain[0] == -1)
                {
                    foreach (var cell in walk.Domain)
                    {
                        if (cell.Key == 0)
                        {
                            continue;
                        }

                        //// If the scalar value of the multiplication operation is 0,
                        //// then simply assign 0 to the cell because n * 0 = 0.
                        //if (cell.Value == 0)
                        //{
                        //    unrolled.Add(new AssignOp(cell.Key, 0));
                        //}
                        //else
                        //{
                        unrolled.Add(new MultiplicationMemoryOp(cell.Key, cell.Value));
                        //}
                    }

                    // If it's a simple loop, then the cell position of the loop should always be assigned a 0 since that's when the loop stops.
                    if (walk.Domain.ContainsKey(0))
                    {
                        unrolled.Add(new AssignOp(0, 0));
                    }

                    return(new LoopUnrollingResults(unrolled, true));
                }
                else
                {
                    return(new LoopUnrollingResults(withUnrolledNestLoops, false));
                }
            }

            return(new LoopUnrollingResults(withUnrolledNestLoops, false));
        }