/// <summary>
        ///     Executes the update and changes the corresponding Text field
        /// </summary>
        /// <returns>true if update was OK (either no change or successful change)</returns>
        public void PerformUpdate(IExpressionable expressionable)
        {
            if (expressionable != null)
            {
                Text  = expressionable.ExpressionText;
                Delta = 0;

                ModelElement.DontRaiseError(() =>
                {
                    if (expressionable.Tree != null)
                    {
                        VisitInterpreterTreeNode(expressionable.Tree);
                        if (Text != expressionable.ExpressionText)
                        {
                            if (expressionable.checkValidExpression(Text))
                            {
                                expressionable.ExpressionText = Text;
                            }
                            else
                            {
                                throw new Exception("Cannot refactor expression " + expressionable.ExpressionText);
                            }
                        }
                    }
                });
            }
        }
Beispiel #2
0
        /// <summary>
        ///     Performs a synchronous compilation
        /// </summary>
        /// <param name="rebuild"></param>
        /// <param name="silent"></param>
        public void Compile_Synchronous(bool rebuild, bool silent = false)
        {
            Options = new CompilationOptions(rebuild, silent);
            ModelElement.DontRaiseError(Options.SilentCompile, () =>
            {
                try
                {
                    // Clears all caches
                    FinderRepository.INSTANCE.ClearCache();

                    // Initialises the declared elements
                    // ReSharper disable once UnusedVariable
                    CleanBeforeCompilation clean_before_compilation = new CleanBeforeCompilation(Options, true);

                    // Create the update information
                    // ReSharper disable once UnusedVariable
                    FindUpdates find_updates = new FindUpdates();

                    // Unifies the state machines and structure according to the update information
                    // ReSharper disable once UnusedVariable
                    Unify unify = new Unify();

                    // Compiles each expression and each statement encountered in the nodes
                    foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries)
                    {
                        visit(dictionary, true);
                    }

                    if (Options.Rebuild)
                    {
                        CreateDependancy create_dependancy = new CreateDependancy();
                        if (create_dependancy.DependancyChange)
                        {
                            // ReSharper disable once UnusedVariable
                            FlattenDependancy flatten_dependancy = new FlattenDependancy();
                        }
                    }
                }
                catch (ThreadAbortException)
                {
                    EfsSystem.Instance.ShouldRebuild = true;
                }
                catch (Exception e)
                {
                    // TODO : I don't know what to do.
                    // Please, at least, don't remove this
                    Debugger.Break();
                    Console.WriteLine();
                    Console.WriteLine(e.Message);
                    Console.WriteLine(e.StackTrace);
                    Console.WriteLine();
                    EfsSystem.Instance.ShouldRebuild = true;
                }
            });
        }
        /// <summary>
        ///     The menu items for this tree node
        /// </summary>
        /// <returns></returns>
        protected override List <MenuItem> GetMenuItems()
        {
            List <MenuItem> retVal = new List <MenuItem>();

            MenuItem newItem = new MenuItem("Add...");

            newItem.MenuItems.Add(new MenuItem("Parameter", AddParameterHandler));
            newItem.MenuItems.Add(new MenuItem("Case", AddCaseHandler));
            retVal.Add(newItem);

            MenuItem updateItem = new MenuItem("Update...");

            updateItem.MenuItems.Add(new MenuItem("Update", AddUpdate));
            updateItem.MenuItems.Add(new MenuItem("Remove", RemoveInUpdate));
            retVal.Add(updateItem);
            retVal.Add(new MenuItem("Delete", DeleteHandler));
            retVal.AddRange(base.GetMenuItems());

            ModelElement.DontRaiseError(() =>
            {
                InterpretationContext context = new InterpretationContext(Item);
                if (Item.FormalParameters.Count == 1)
                {
                    Parameter parameter = (Parameter)Item.FormalParameters[0];
                    Graph graph         = Item.CreateGraph(context, parameter, null);
                    if (graph != null && graph.Segments.Count != 0)
                    {
                        retVal.Insert(7, new MenuItem("Display", DisplayHandler));
                    }
                }
                else if (Item.FormalParameters.Count == 2)
                {
                    Surface surface = Item.CreateSurface(context, null);
                    if (surface != null && surface.Segments.Count != 0)
                    {
                        retVal.Insert(7, new MenuItem("Display", DisplayHandler));
                    }
                }
            });

            return(retVal);
        }