Пример #1
0
        /// <summary>
        /// Get evaluated variable or property value for specified scope.
        /// </summary>
        /// <param name="name">Access to property or variable by its name.</param>
        /// <param name="scope">Where is placed. null value for global or unspecified scope.</param>
        /// <returns>Evaluated value.</returns>
        public virtual string GetPropValue(string name, string scope = null)
        {
            if (UVars.IsExist(name, scope))
            {
                LSender.Send(this, $"Evaluate: use '{name}:{scope}' from user-variable");
                return(GetUVarValue(name, scope));
            }

            if (scope == null)
            {
                string slnProp = env.GetMutualPropValue(name);
                if (slnProp != null)
                {
                    LSender.Send(this, $"Solution-context for getProperty - '{name}' = '{slnProp}'");
                    return(slnProp);
                }
            }

            ProjectProperty prop = GetProject(scope).GetProperty(name);

            if (prop != null)
            {
                return(prop.EvaluatedValue);
            }
            LSender.Send(this, "getProperty: return default value");
            return(UNDEF_VAL);
        }
Пример #2
0
        /// <summary>
        /// Magic methods. Invoking.
        /// </summary>
        /// <![CDATA[
        ///     `[result =] name<return_type>([{argument_types}])`
        /// ]]>
        /// <param name="binder"></param>
        /// <param name="args"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            Type[] tArgs;

            try {
                tArgs = getArgTypes(binder, args);
            }
            catch (ArgumentException ex) {
                LSender.Send(this, $"Problem with arguments. DLR for '{binder.Name}': {ex.Message}", Message.Level.Warn);
                tArgs = args.Select(a => a.GetType()).ToArray();
            }

            Type[]     tGeneric = getGenericArgTypes(binder).ToArray();
            MethodInfo mi       = getmi(binder.Name, tGeneric, tArgs);

            TDyn dyn = provider.bind(
                mi,
                provider.Svc.tryAlias(binder.Name),
                Convention
                );

            // Boxing types, for example: NullType -> null -> NullType

            object[] unboxed = unbox(args);
            result = Dynamic.DCast(dyn.returnType, dyn.dynamic.Invoke(null, unboxed));
            boxing(unboxed, args);

            return(true);
        }
Пример #3
0
        private protected void DefProperty(AVariable variable, string evaluated)
        {
            LSender.Send(this, $"Set property: `{variable.name}`:`{variable.scope}`");

            //defProperty(uvariable.getVariable(variable.name, variable.scope), getProject(variable.scope));
            SetGlobalProperty(GetProject(variable.scope), variable.name, evaluated);
        }
Пример #4
0
        /// <summary>
        /// Callback function used with the SetWindowsHookEx function.
        /// The system calls this function every time a new mouse input event is about to be posted into a thread input queue.
        /// </summary>
        /// <param name="nCode">A code the hook procedure uses to determine how to process the message.</param>
        /// <param name="wParam">The identifier of the mouse message.</param>
        /// <param name="lParam">A pointer to an MSLLHOOKSTRUCT structure.</param>
        /// <returns></returns>
        private LRESULT lowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam)
        {
            int recode = findReCode(wParam);

            int idx = 0;

            foreach (IMouseListener listener in Loader.ActivatedFilters)
            {
                if (recode != -1 && idx++ <= recode)
                {
                    continue;
                }

                FilterResult act = listener.msg(nCode, wParam, lParam);

                if (act == FilterResult.IgnoreFilters)
                {
                    break;
                }
                else if (act == FilterResult.Continue)
                {
                    continue;
                }

#if DEBUG
                LSender.Send(this, $"prevent msg({nCode}, {wParam}, {lParam}) by filter {listener.Id}:'{listener.Name}'", Message.Level.Trace);
#endif
                return(stopChainCode);
            }

            return(NativeMethods.CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
        }
Пример #5
0
        public TrayForm(IBootloader loader, FormWindowState state)
        {
            if (loader == null)
            {
                throw new ArgumentNullException("Bootloader cannot be null.");
            }
            this.loader = loader;
            svc         = new Mokona(loader);

            fic = listener(typeof(InterruptedClickFilter));
            fmc = listener(typeof(MixedClicksFilter));
            fdc = listener(typeof(DoubleClicksFilter));
            fhs = listener(typeof(HyperactiveScrollFilter));

            InitializeComponent();

            origin = ClientSize;
            try {
                notifyIconMain.Icon             = Icon
                                                = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
            }
            catch (ArgumentException ex) {
                notifyIconMain.Icon = Icon;
                LSender.Send(this, ex.Message, Log.Message.Level.Debug);
            }

            hotKeys.KeyPress += onHotKeys;
            log.Received     += onLogMsgReceived;

            fic.Triggering += (object sender, DataArgs <ulong> e) => {
                uiAction(() => labelInterruptedClick.Text = e.Data.ToString());
            };

            fmc.Triggering += (object sender, DataArgs <ulong> e) => {
                uiAction(() => labelMixedClicks.Text = e.Data.ToString());
            };

            fdc.Triggering += (object sender, DataArgs <ulong> e) => {
                uiAction(() => labelDoubleClick.Text = e.Data.ToString());
            };

            fhs.Triggering += (object sender, DataArgs <ulong> e) => {
                uiAction(() => labelHyperactiveScroll.Text = e.Data.ToString());
            };

            WindowState = state;
            Resize     += (object _sender, EventArgs _e) => {
                visible(WindowState);
            };

            Modifiers mcomb = Modifiers.ControlKey | Modifiers.AltKey | Modifiers.ShiftKey;

            try {
                hotKeys.register(mcomb, Keys.Z);
                hotKeys.register(mcomb, Keys.X);
            }
            catch (Exception ex) {
                log.send(this, ex.Message, Log.Message.Level.Error);
            }
        }
Пример #6
0
        /// <summary>
        /// New position in stream.
        /// </summary>
        /// <param name="svc"></param>
        /// <param name="line">Received line.</param>
        /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns>
        public override bool Positioned(ISvc svc, RawText line)
        {
            if (svc.Sln.ExtItems == null)
            {
                svc.Sln.ExtItems = new Dictionary <string, string>();
            }

            string _line;

            while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection")
            {
                int pos = _line.IndexOf('=');
                if (pos < 0) // we will use non-strict processing
                {
                    svc.Sln.ExtItems[_line.Trim()] = null;
                    LSender.Send(this, $"Found extensible null record:{_line}", Message.Level.Info);
                    continue;
                }

                string key = _line.Substring(0, pos).Trim();
                string val = _line.Substring(pos + 1).Trim();

                svc.Sln.ExtItems[key] = val;
                LSender.Send(this, $"Found extensible key-value: `{key}` = `{val}`", Message.Level.Info);
            }

            return(true);
        }
Пример #7
0
        protected virtual void CopyFile(string destDir, string destFile, bool overwrite, params string[] files)
        {
            if (!Directory.Exists(destDir))
            {
                LSender.Send(this, $"Trying to create directory `{destDir}`", MsgLevel.Trace);
                Directory.CreateDirectory(destDir);
            }

            bool isDestFile = !string.IsNullOrWhiteSpace(destFile);

            if (isDestFile && files.Length > 1)
            {
                throw new ArgumentException(
                          string.Format(
                              "The destination path `{0}` cannot contain file name `{1}` if the source has 2 or more files for used mask. End with `{1}\\` or `{1}/` if it directory.",
                              destDir,
                              destFile
                              )
                          );
            }

            foreach (string file in files)
            {
                string dest = Path.Combine(destDir, isDestFile ? destFile : Path.GetFileName(file));
                LSender.Send(this, $"Copy file `{file}` to `{dest}` overwrite({overwrite})", MsgLevel.Trace);
                File.Copy(file, dest, overwrite);
            }
        }
Пример #8
0
        /// <summary>
        /// Prepare, parse, and evaluate mixed data through SobaScript supported syntax.
        /// </summary>
        /// <param name="data">Mixed input data.</param>
        /// <returns>Evaluated end value.</returns>
        public override string Eval(string data)
        {
            var    point   = EntryPoint(data.Trim());
            string subtype = point.Key;
            string request = point.Value;

            LSender.Send(this, $"`{ToString()}`: subtype - `{subtype}`, request - `{request}`", MsgLevel.Trace);

            IPM pm = new PM(request, emsbuild);

            switch (subtype)
            {
            case "cancel": {
                return(StCancel(pm));
            }

            case "projects": {
                return(StProjects(pm));
            }

            case "type": {
                return(StType(pm));
            }

            case "solution": {
                return(StSolution(pm));
            }
            }

            throw new SubtypeNotFoundException(subtype);
        }
Пример #9
0
        protected virtual void CopyDirectory(IEnumerable <string[]> files, string dest, bool force, bool overwrite)
        {
            if (!Directory.Exists(dest))
            {
                if (!force)
                {
                    throw new NotFoundException(dest, "Check path or use `force` flag");
                }

                LSender.Send(this, $"Trying to create directory `{dest}`", MsgLevel.Trace);
                Directory.CreateDirectory(dest);
            }

            foreach (var file in files.ToArray())
            {
                string from = file[0];
                string to   = file[1];

                string subdir = Path.GetDirectoryName(to);
                if (!Directory.Exists(subdir))
                {
                    Directory.CreateDirectory(subdir);
                }

                LSender.Send(this, $"Copy directory: file `{from}` to `{to}` overwrite({overwrite})", MsgLevel.Trace);
                File.Copy(from, to, overwrite);
            }
        }
Пример #10
0
        /// <summary>
        /// New position in stream.
        /// </summary>
        /// <param name="svc"></param>
        /// <param name="line">Received line.</param>
        /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns>
        public override bool Positioned(ISvc svc, RawText line)
        {
            string _line;

            while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection")
            {
                int pos = _line.IndexOf('='); // Guids: src = dest
                if (pos < 0)
                {
                    LSender.Send(this, $"Incorrect NestedProjects records: '{_line}'", Message.Level.Warn);
                    return(false);
                }

                string src  = _line.Substring(0, pos).Trim();
                string dest = _line.Substring(pos + 1).Trim();

                LSender.Send(this, $"NestedProjects '{src}' -> '{dest}'", Message.Level.Info);

                var parent = svc.Sln.SolutionFolderList.Where(f => f.header.pGuid == dest).First();

                svc.Sln.SolutionFolderList.Where(f => f.header.pGuid == src)
                .ForEach(f => f.header.parent.Value = parent);

                svc.Sln.ProjectItemList.Where(p => p.pGuid == src)
                .ForEach(p => p.parent.Value = parent);
            }

            return(true);
        }
Пример #11
0
        /// <summary>
        /// Evaluate user-variable with IEvaluator by using unique identification.
        /// An evaluated value should be updated for variable.
        /// </summary>
        /// <param name="ident">Unique identificator</param>
        /// <param name="evaluator">IEvaluator objects for evaluating</param>
        /// <param name="resetting">To reset IEvaluator chain to initial state if true. Otherwise, evaluation can be in the chain of other evaluators.</param>
        public void Evaluate(string ident, IEvaluator evaluator, bool resetting)
        {
            if (evaluator == null)
            {
                throw new ArgumentNullException(nameof(evaluator));
            }

            lock (sync)
            {
                if (!definitions.ContainsKey(ident))
                {
                    throw new DefinitionNotFoundException(ident);
                }

                TVariable var = new TVariable(definitions[ident])
                {
                    status = ValStatus.Started
                };
                definitions[ident] = var;

                if (resetting)
                {
                    var.evaluated = evaluator.Evaluate(var.unevaluated);
                }
                else
                {
                    var.evaluated = evaluator.Evaluate(var.evaluated);
                }
                var.status         = ValStatus.Evaluated;
                definitions[ident] = var;
                LSender.Send(this, $"IEvaluator '{evaluator.GetType().ToString()}': Evaluation of variable '{ident}' is completed.", MsgLevel.Trace);
            }
        }
Пример #12
0
        private bool Unload(Project prj)
        {
            if (prj == null)
            {
                return(false);
            }

            try
            {
                if (prj.FullPath != null)
                {
                    ProjectCollection.GlobalProjectCollection.UnloadProject(prj);
                }
                else if (prj.Xml != null)
                {
                    ProjectCollection.GlobalProjectCollection.TryUnloadProject(prj.Xml);
                }

                return(true);
            }
            catch (Exception ex)
            {
                LSender.Send(this, $"Project cannot be unloaded due to error: '{ex.Message}'", MsgLevel.Debug);
                return(false);
            }
        }
Пример #13
0
        protected bool free()
        {
            if (!Library.IsActive)
            {
                LSender.Send(this, $"Dispose Library: it's not activated.", Message.Level.Trace);
                return(true);
            }

            BeforeUnload(this, new DataArgs <Link>(Library));

            try {
                return(NativeMethods.FreeLibrary(Library.Handle));
            }
            finally
            {
                AfterUnload(
                    this,
                    new DataArgs <Link>(
                        new Link(Library.LibName)
                        )
                    );

                if (PE != null)
                {
                    LSender.Send(this, $"Dispose PE: file ({PE.FileName})", Message.Level.Debug);
                    ((IDisposable)PE).Dispose();
                }
            }
        }
        /// <summary>
        /// New position in stream.
        /// </summary>
        /// <param name="svc"></param>
        /// <param name="line">Received line.</param>
        /// <returns>true if it was processed by current handler, otherwise it means ignoring.</returns>
        public override bool Positioned(ISvc svc, RawText line)
        {
            if (svc.Sln.SolutionConfigList == null)
            {
                svc.Sln.SolutionConfigList = new List <IConfPlatform>();
            }

            string _line;

            while ((_line = svc.ReadLine(this)) != null && _line.Trim() != "EndGlobalSection")
            {
                string left = _line.Before('=')?.Trim(); // Debug|Win32 = Debug|Win32
                if (left == null ||
                    String.Compare(left, "DESCRIPTION", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    LSender.Send(this, $"Solution Configuration has been ignored for line '{_line}'", Message.Level.Debug);
                    continue;
                }

                string[] cfg = left.Split('|');
                if (cfg.Length < 2)
                {
                    continue;
                }

                LSender.Send(this, $"Solution Configuration ->['{cfg[0]}' ; '{cfg[1]}']", Message.Level.Info);
                svc.Sln.SolutionConfigList.Add(new ConfigSln(cfg[0], cfg[1]));
            }

            return(true);
        }
Пример #15
0
        private void btnExt_Click(object sender, EventArgs e)
        {
            if (extcfg.IsValueCreated)
            {
                ((Kit.FilterLineControl)extcfg.Value).Show();
                return;
            }

            LSender.Send(this, $"Create {nameof(Kit.FilterLineControl)} panel");

            var panel = ((Kit.FilterLineControl)extcfg.Value);

            panel.Left   = 0;
            panel.Top    = 0;
            panel.Width  = panelTop.Width;
            panel.Height = panelTop.Height /* - progressLine.Height*/;

            panelTop.Controls.Add(panel);
            panel.Dock = DockStyle.Fill;

            panel.BringToFront();
            progressLine.BringToFront();

            panel.Show();
        }
Пример #16
0
        public void SendVectorTest1()
        {
            LSender.Reset();

            LSender.Sent += (object sender, MsgArgs e) =>
            {
                Assert.True(e.At("LSenderTest"));
                Assert.True(e.At("DepC", "LSenderTest"));
                Assert.True(e.At("DepC", "DepB", "LSenderTest"));
                Assert.True(e.At("DepC", "DepB", "DepA", "LSenderTest"));

#if LSR_FEATURE_S_VECTOR
                Assert.False(e.At("DepB", "DepC", "LSenderTest"));
                Assert.False(e.At("DepA", "DepB", "LSenderTest"));
#else
                Assert.True(e.At("DepB", "DepC", "LSenderTest"));
                Assert.True(e.At("DepA", "DepB", "LSenderTest"));
#endif

                Assert.True(e.At("DepB", "DepA", "LSenderTest"));
            };

            DepA.ClassA.SendStatic(string.Empty);
            DepA.ClassA.SendInstance(string.Empty);
        }
Пример #17
0
 private static void UnknownFail(Exception ex, bool threadEx)
 {
     LSender.Send <Executor>(
         $"{ex.Message}{(threadEx ? "[TH]" : "[M]")}\n---\n{ex.ToString()}",
         MvsSln.Log.Message.Level.Fatal
         );
 }
Пример #18
0
 /// <summary>
 /// Remove all user-variables
 /// </summary>
 public void UnsetAll()
 {
     lock (sync) {
         definitions.Clear();
     }
     LSender.Send(this, "Reseted all User-variables", MsgLevel.Trace);
 }
Пример #19
0
        public void IsInTest1()
        {
            LSender.Reset();

            LSender.Sent += (object sender, MsgArgs e) =>
            {
#if LSR_FEATURE_S_VECTOR
                Assert.NotEmpty(e.vector);
                Assert.True(e.At("LSenderTest"));
                Assert.False(e.At("vsSolutionBuildEvent"));

                Assert.False(e.At("LSenderTest", "vsSolutionBuildEvent"));
                Assert.False(e.At("vsSolutionBuildEvent", "LSenderTest"));
#else
                Assert.Empty(e.vector);
                Assert.True(e.At("LSenderTest"));
                Assert.True(e.At("vsSolutionBuildEvent"));

                Assert.True(e.At("LSenderTest", "vsSolutionBuildEvent"));
                Assert.True(e.At("vsSolutionBuildEvent", "LSenderTest"));
#endif
            };

            LSender.Send(this, new MsgArgs(""));
        }
Пример #20
0
        protected Platform GetPlatform(string value)
        {
            if (String.IsNullOrWhiteSpace(value))
            {
                return(Platform.Default);
            }

            switch (value.Trim().ToLowerInvariant())
            {
            case "x86":
            case "x32":
            case "win32": {
                return(Platform.x86);
            }

            case "x64": {
                return(Platform.x64);
            }

            case "anycpu":
            case "any cpu": {
                return(Platform.AnyCPU);
            }
            }

            LSender.Send(this, $"Incorrect platform target: '{value}'. Use '{nameof(Platform.Default)}'", Message.Level.Warn);
            return(Platform.Default);
        }
Пример #21
0
        /// <summary>
        /// Defines user-variable.
        /// Value setted as unevaluated.
        /// </summary>
        /// <param name="name">Variable name.</param>
        /// <param name="scope">Specified scope for this variable.</param>
        /// <param name="unevaluated">Mixed string with unevaluated data.</param>
        public void SetVariable(string name, string scope, string unevaluated)
        {
            if (!IsValidName(name) || !IsValidScope(scope))
            {
                throw new ArgumentException($"name - '{name}' or scope - '{scope}' is not valid for variable");
            }
            string defindex = DefIndex(name, scope);

            if (unevaluated == null)
            {
                unevaluated = String.Empty;
            }

            lock (sync)
            {
                definitions[defindex] = new TVariable()
                {
                    unevaluated = unevaluated,
                    ident       = defindex,
                    name        = name,
                    scope       = scope,
                    status      = ValStatus.Unevaluated,
                    prev        = (definitions.ContainsKey(defindex))? definitions[defindex] : new TVariable(),
                    evaluated   = null
                };
                LSender.Send(this, $"User-variable: defined '{defindex}' = '{unevaluated}'");
            }
        }
Пример #22
0
        /// <summary>
        /// Construct data from used components with ISobaCLoader.
        /// </summary>
        /// <param name="cLoader"></param>
        public Inspector(ISobaCLoader cLoader)
        {
            this.cLoader = cLoader;
            foreach (IComponent c in cLoader.Registered)
            {
#if DEBUG
                LSender.Send(this, $"extracting from '{c.GetType().Name}'", MsgLevel.Trace);
#endif
                Extract(c, data);
            }

            if (data.Count < 1)
            {
                return;
            }

            // Aliases to components
            foreach (var root in data[new NodeIdent()])
            {
                if (root.Aliases == null)
                {
                    continue;
                }
                foreach (string alias in root.Aliases)
                {
                    data[new NodeIdent(alias, root.Link.method, root.Link.className)] = data[root.Link]; //shallow copies
                }
            }
        }
Пример #23
0
        /// <summary>
        /// Prepare, parse, and evaluate mixed data through SobaScript supported syntax.
        /// </summary>
        /// <param name="data">Mixed input data.</param>
        /// <returns>Evaluated end value.</returns>
        public override string Eval(string data)
        {
            var    point   = EntryPoint(data, RegexOptions.Singleline);
            string subtype = point.Key;
            string request = point.Value;

            LSender.Send(this, $"`{ToString()}`: subtype - `{subtype}`, request - `{request}`", MsgLevel.Trace);

            switch (subtype)
            {
            case "out": {
                return(StOut(new PM(request)));
            }

            case "log": {
                return(StLog(new PM(request)));
            }

            case "item": {
                return(StItem(new PM(request)));
            }
            }

            throw new SubtypeNotFoundException(subtype);
        }
Пример #24
0
        protected virtual string DoRepeat(string condition, string block, string iterator, bool silent)
        {
            LSender.Send(this, $"DoRepeat: condition `{condition}`; block `{block}`; silent: {silent}");
            string ret = string.Empty;

#if DEBUG
            long idx = 0;
#endif
            while (expression.IsTrue(condition))
            {
                if (silent)
                {
                    Evaluate(block);
                }
                else
                {
                    ret += Evaluate(block);
                }

                if (iterator != null)
                {
                    Evaluate(iterator);
                }

#if DEBUG
                if (++idx > iterationLimit)
                {
                    throw new LimitException($"Iteration Limit of '{iterationLimit}' reached. Aborted.", iterationLimit);
                }
#endif
            }

            return(ret);
        }
Пример #25
0
        /// <summary>
        /// Gets full path to file with environment PATH.
        /// </summary>
        /// <returns>null value if file is not found</returns>
        protected virtual string FindFile(string file)
        {
            string lfile = GetLocation(file);

            if (File.Exists(lfile))
            {
                return(lfile);
            }

            LSender.Send(this, $"finding file with environment PATH :: `{file}`({lfile})", MsgLevel.Trace);

            string[] exts = Environment.GetEnvironmentVariable("PATHEXT").Split(';');

            foreach (string dir in EnvPath)
            {
                lfile = GetLocation(file, dir);
                if (File.Exists(lfile) || exts.Any(ext => File.Exists(lfile + ext)))
                {
                    LSender.Send(this, $"found in: '{dir}' :: '{lfile}'", MsgLevel.Trace);
                    return(lfile);
                }
            }

            return(null);
        }
Пример #26
0
        protected virtual bool tryIsolateModule(Link l, out string module)
        {
            try
            {
                if (!l.resolved && !Path.HasExtension(l.module) && GetModuleFileName(l, out string fname))
                {
                    module = fname;
                }
                else
                {
                    module = l.module;
                }

                var dstDir = Path.Combine(Path.GetTempPath(), CLLI, Guid.NewGuid().ToString());
                Directory.CreateDirectory(dstDir);

                var dst = Path.Combine(dstDir, Path.GetFileName(module));
                File.Copy(module, dst, true);

                module = dst;
                return(true);
            }
            catch (Exception ex)
            {
                //TODO: option to throw exception
                LSender.Send(this, $"Something went wrong when trying to isolate `{l.module}`: {ex.Message}", Message.Level.Debug);

                module = null;
                return(false);
            }
        }
Пример #27
0
        private void ShowFilterPanel()
        {
            if (extcfg.IsValueCreated)
            {
                ((FilterLineControl)extcfg.Value).Show();
                return;
            }

            LSender.Send(this, $"Create {nameof(FilterLineControl)} panel");

            var panel = (FilterLineControl)extcfg.Value;

            panel.Left   = 0;
            panel.Top    = 0;
            panel.Width  = panelFilter.Width;
            panel.Height = panelFilter.Height;

            panelFilter.Controls.Add(panel);
            panel.Dock = DockStyle.Fill;

            panel.BringToFront();
            progressLine.BringToFront();

            panel.Show();
        }
Пример #28
0
 protected virtual void Mkdir(string path)
 {
     if (!Directory.Exists(path))
     {
         LSender.Send(this, $"Create empty directory `{path}`", MsgLevel.Trace);
         Directory.CreateDirectory(path);
     }
 }
Пример #29
0
        private protected bool UndefProperty(AVariable variable)
        {
            LSender.Send(this, $"Unset property: `{variable.name}`:`{variable.scope}`");
            Project project = GetProject(variable.scope);

            //uvariable.unset(variable.name, variable.scope); //leave for sbe-scripts
            return(RemoveGlobalProperty(project, variable.name));
        }
Пример #30
0
 protected virtual void DeleteFiles(string[] files)
 {
     foreach (string file in files)
     {
         LSender.Send(this, $"Delete file `{file}`", MsgLevel.Trace);
         File.Delete(file);
     }
 }