object EvaluateExpression(ScriptingContext context, string expression)
        {
            try {
                Expression expr = context.ParseExpression(expression);

                expr = expr.Resolve(context);
                if (expr == null)
                {
                    Assert.Fail("Cannot resolve expression `{0}'.", expression);
                }

                object obj = expr.Evaluate(context);
                if (obj == null)
                {
                    Assert.Fail("Failed to evaluate expression `{0}.", expression);
                }

                return(obj);
            } catch (ScriptingException) {
                throw;
            } catch (AssertionException) {
                throw;
            } catch (Exception ex) {
                Assert.Fail("Failed to evalaute expression `{0}': {1}",
                            expression, ex);
                return(null);
            }
        }
        TargetType EvaluateExpressionType(ScriptingContext context, string expression)
        {
            try {
                Expression expr = context.ParseExpression(expression);

                Expression resolved = expr.TryResolveType(context);
                if (resolved != null)
                {
                    expr = resolved;
                }
                else
                {
                    expr = expr.Resolve(context);
                }
                if (expr == null)
                {
                    Assert.Fail("Cannot resolve expression `{0}'.", expression);
                }

                return(expr.EvaluateType(context));
            } catch (ScriptingException) {
                throw;
            } catch (AssertionException) {
                throw;
            } catch (Exception ex) {
                Assert.Fail("Failed to evalaute type of expression `{0}': {1}",
                            expression, ex);
                return(null);
            }
        }
        public void AssertTypeException(Thread thread, string expression, string exp_result)
        {
            string text = null;

            try {
                ScriptingContext context = GetContext(thread);

                TargetType type = EvaluateExpressionType(context, expression);
                text = context.FormatType(type);
                Assert.Fail("Evaluation of expression `{0}' failed to throw " +
                            "exception {1}.", expression, exp_result);
            } catch (AssertionException) {
                throw;
            } catch (ScriptingException ex) {
                text = ex.Message;
            } catch (Exception ex) {
                Assert.Fail("Failed to print expression `{0}': {1}",
                            expression, ex);
            }

            if (text != exp_result)
            {
                Assert.Fail("Expression `{0}' evaluated to `{1}', but expected `{2}'.",
                            expression, text, exp_result);
            }
        }
Example #4
0
            protected override object DoExecute(ScriptingContext context)
            {
                // try-catch: on exceptions, we must release the semaphore
                try {
                    EmonicInterpreter.localsOutput = "";
                    foreach (TargetVariable var in locals)
                    {
                        if (!var.IsInScope(CurrentFrame.TargetAddress))
                        {
                            continue;
                        }

                        EmonicInterpreter.localsOutput += var.Name;
                        EmonicInterpreter.localsOutput += " ";

                        string msg = context.Interpreter.Style.PrintVariable(var, CurrentFrame);
                        context.Interpreter.Print(msg);
                    }
                    EmonicInterpreter.localsOutput = EmonicInterpreter.localsOutput.Trim();
                    EmonicInterpreter.localsSem.Release();
                    return(null);
                } catch {
                    EmonicInterpreter.localsOutput = "--";
                    EmonicInterpreter.localsSem.Release();
                    throw;
                }
            }
        public void AssertPrintRegex(Thread thread, DisplayFormat format,
                                     string expression, string exp_re)
        {
            string text = null;

            try {
                ScriptingContext context = GetContext(thread);

                object obj = EvaluateExpression(context, expression);
                text = context.FormatObject(obj, format);
            } catch (AssertionException) {
                throw;
            } catch (Exception ex) {
                Assert.Fail("Failed to print expression `{0}': {1}",
                            expression, ex);
            }

            Match match = Regex.Match(text, exp_re);

            if (!match.Success)
            {
                Assert.Fail("Expression `{0}' evaluated to `{1}', but expected `{2}'.",
                            expression, text, exp_re);
            }
        }
        ScriptingContext GetContext(Thread thread)
        {
            ScriptingContext context = new ScriptingContext(interpreter);

            context.CurrentThread = thread;
            context.CurrentFrame  = thread.CurrentFrame;
            return(context);
        }
Example #7
0
        /// <summary>
        /// Handles the Execute command.
        /// </summary>
        private void HandleExecuteCommand(object sender, ExecutedRoutedEventArgs e)
        {
            ScriptingContext.VerifyCommand(CurrentCommand);
            var command = CurrentCommand;

            CurrentCommand = string.Empty;
            ScriptingContext.ExecuteCommand(command);
            History.Add(command);
        }
        private void Init()
        {
            Result <string> scriptsPath = FileIO.SearchAFolderAboveTheCurrentDirectoryOfTheApplication(Settings.ScriptsPath_JsScripts); // find the folder with the scripts

            if (scriptsPath.IsFailure)
            {
                throw new InvalidOperationException("scripts folder not found");
            }
            jsScriptingContext = ScriptingContext.ScriptingContextWithRealFs(scriptsPath.Value);
        }
        private (string ScriptsPath, ScriptingContext JsScriptingContext) InitWithRealFs()
        {
            Result <string> scriptsPath = FileIO.SearchAFolderAboveTheCurrentDirectoryOfTheApplication(Scripting_TestSettings.ScriptsPath_JsScripts); // find the folder with the scripts

            if (scriptsPath.IsFailure)
            {
                throw new InvalidOperationException("scripts folder not found");
            }
            //return (scriptsPath.Value, ScriptingContext.ScriptingContextWithInMemoryFs(InMemoryScripts.GetScripts()));
            return(scriptsPath.Value, ScriptingContext.ScriptingContextWithRealFs(scriptsPath.Value));
        }
        async Task IKustoManagementGateway.ExecuteCommandsAsync(
            IEnumerable <CommandBase> commands,
            CancellationToken ct)
        {
            if (commands.Any())
            {
                _tracer.WriteLine(true, ".execute database script commands start");

                var tracerTimer      = new TracerTimer(_tracer);
                var scriptingContext = new ScriptingContext
                {
                    CurrentDatabaseName = new EntityName(_database)
                };
                var commandScripts = commands.Select(c => c.ToScript(scriptingContext));
                var fullScript     = ".execute database script with (ThrowOnErrors=true) <|"
                                     + Environment.NewLine
                                     + string.Join(Environment.NewLine + Environment.NewLine, commandScripts);
                var output = await ExecuteCommandAsync(fullScript, ct);

                _tracer.WriteLine(true, ".execute database script commands end");
                tracerTimer.WriteTime(true, ".execute database script commands time");

                var content = Select(
                    output,
                    r => new
                {
                    Result      = (string)r["Result"],
                    Reason      = (string)r["Reason"],
                    CommandText = (string)r["CommandText"],
                    OperationId = (Guid)r["OperationId"]
                });
                var failedItems = content.Where(t => t.Result != "Completed");

                if (failedItems.Any())
                {
                    var failedItem        = failedItems.First();
                    var failedItemCommand = PackageString(failedItem.CommandText);
                    var allCommands       = string.Join(
                        ", ",
                        content.Select(i => $"({i.Result}:  '{PackageString(i.CommandText)}')"));

                    throw new InvalidOperationException(
                              $"Command failed to execute with reason '{failedItem.Reason}'.  "
                              + $"Operation ID:  {failedItem.OperationId}.  "
                              + $"Cluster URI:  {_clusterUri}.  "
                              + $"Database:  {_database}.  "
                              + $"Command:  '{failedItemCommand}'.  "
                              + $"All commands:  {allCommands}");
                }
            }
        }
Example #11
0
    public static void UseInteractive(InteractionDef interaction)
    {
        var ui        = FindObjectOfType <UIVisual>();
        var character = ui.Character;
        var targetCtx = new ScriptingContext()
        {
            ProcessingEntity = character,
            Host             = ((NetworkEntity)ui.Interactive).Id
        };

        if (interaction.Predicate.Def == null || interaction.Predicate.Def.Check(targetCtx))
        {
            ((IImpactedEntity)character).RunImpact(null, interaction.Impact.Def);
        }
    }
Example #12
0
        public void Jint_Scripting_InMemoryFiles_Test()
        {
            //Assert.Inconclusive(); return;

            ScriptingContext jsScriptingContext = ScriptingContext.ScriptingContextWithInMemoryFs(ES5_scripts_to_zip_plus_to_encode_in_Base64.GetScripts());

            JsScriptRunner jsScriptRunner = JsScriptRunner.RunnerWithContext(
                JsScriptRunnerType.Jint,
                jsScriptingContext,
                Scripting_TestSettings.ScriptingContextName);

            jsScriptRunner.Run("var exports = {};");                                 // required by the row of 'main.js' ```Object.defineProperty(exports, "__esModule", { value: true });``` generated by TypeScript
            jsScriptRunner.Run(jsScriptingContext.ReadFile("./lib/myrequire.js"));   // load a custom version of 'require'
            jsScriptRunner.Run(jsScriptingContext.ReadFile("main.js"));              // execute script from virtual FS (would have been the same executing "./main.js")
            Assert.AreEqual("Hello World", jsScriptingContext.ReadFile("filename")); // test output of Js scripts
        }
Example #13
0
        private void Initialize()
        {
            if (_initialized)
            {
                return;
            }
            ScriptingContext = new ScriptingContext
            {
                SimSupportModules      = GetRegisteredSimSupportModules(),
                HardwareSupportModules = GetRegisteredHardwareSupportModules()
            };

            AddPerformanceMonitoringSignals();
            InitializeMappings();
            _initialized = true;
        }
Example #14
0
        protected override object DoExecute(ScriptingContext context)
        {
            Event handle;

            if (!address.IsNull)
            {
                handle = context.Interpreter.Session.InsertBreakpoint(
                    context.CurrentThread, tgroup, address);
                context.Print("Breakpoint {0} at {1}", handle.Index, address);
            }
            else if (location != null)
            {
                // line breakpoints use this method!
                handle = context.Interpreter.Session.InsertBreakpoint(
                    tgroup, location);
                context.Print("Breakpoint {0} at {1}", handle.Index, location.Name);
            }
            else
            {
                handle = context.Interpreter.Session.InsertBreakpoint(
                    tgroup, type, Argument);
                context.Print("Breakpoint {0} at {1}", handle.Index, Argument);
            }

            if (!context.Interpreter.HasTarget)
            {
                EmonicInterpreter.breakpointNumber = handle.Index;
                EmonicInterpreter.breakpointSem.Release();
                return(handle.Index);
            }

            try {
                handle.Activate(context.Interpreter.CurrentThread);
            } catch {
                if (!lazy)
                {
                    EmonicInterpreter.breakpointNumber = -1;
                    EmonicInterpreter.breakpointSem.Release();
                    throw;
                }
            }

            EmonicInterpreter.breakpointNumber = handle.Index;
            EmonicInterpreter.breakpointSem.Release();

            return(handle.Index);
        }
Example #15
0
            protected override bool DoResolve(ScriptingContext context)
            {
                // try-catch: on exceptions, we must release the semaphore
                try {
                    if (CurrentFrame.Method == null)
                    {
                        throw new ScriptingException(
                                  "Selected stack frame has no method.");
                    }

                    locals = CurrentFrame.Method.GetLocalVariables(context.CurrentThread);
                    return(true);
                } catch {
                    EmonicInterpreter.localsOutput = "--";
                    EmonicInterpreter.localsSem.Release();
                    throw;
                }
            }
Example #16
0
            protected override bool DoResolve(ScriptingContext context)
            {
                // catch exceptions and release the semaphore in case of one
                try {
                    if (CurrentFrame.Method == null)
                    {
                        throw new ScriptingException(
                                  "Selected stack frame has no method.");
                    }

                    param_vars = CurrentFrame.Method.GetParameters(context.CurrentThread);
                    return(true);
                } catch {
                    EmonicInterpreter.paramsOutput = "--";
                    EmonicInterpreter.paramsSem.Release();
                    throw;
                }
            }
 public object EvaluateExpression(Thread thread, string expression)
 {
     try {
         ScriptingContext context = GetContext(thread);
         object           obj     = EvaluateExpression(context, expression);
         if (obj == null)
         {
             Assert.Fail("Failed to evaluate expression `{0}'", expression);
         }
         return(obj);
     } catch (AssertionException) {
         throw;
     } catch (Exception ex) {
         Assert.Fail("Failed to print expression `{0}': {1}",
                     expression, ex);
         return(null);
     }
 }
Example #18
0
        public void Apply(ScriptingContext ctx)
        {
            var ae = ctx.ProcessingEntity.CurrentServer.GetGhost(ctx.Host) as IHasActionEngine;

            if (ae == null)
            {
                return;
            }
            else
            {
                var spell = ae.ActionEngine.GetSpell(InvokedSpell.Def);
                if (spell != null)
                {
                    var pe = ctx.ProcessingEntity.CurrentServer.GetGhost(ctx.Host) as IPositionedEntity;

                    (ae as IHasSpells).SpellsEngine.FireAndForgetCast(new SpellCast()
                    {
                        Def = spell, OwnerObject = ctx.Host, TargetEntity = ctx.Host, TargetPoint = pe?.Position ?? default
                    });
Example #19
0
        protected override string Execute(ScriptingContext context,
                                          Expression expression, DisplayFormat format)
        {
            // try-catch block for whole method: if an exception occurs, we are able to
            // release the semaphore waiting for the command answer
            try {
                TargetType type = expression.EvaluateType(context);

                string fieldNames           = "";
                string fieldNamesStaticOnly = "";
                if (type.Kind == TargetObjectKind.Class || type.Kind == TargetObjectKind.Struct)
                {
                    TargetClassType stype = (TargetClassType)type;
                    foreach (TargetFieldInfo field in stype.Fields)
                    {
                        fieldNames += field.Name;
                        fieldNames += " ";
                        if (field.IsStatic)
                        {
                            fieldNamesStaticOnly += field.Name;
                            fieldNamesStaticOnly += " ";
                        }
                    }
                    fieldNames           = fieldNames.Trim();
                    fieldNamesStaticOnly = fieldNamesStaticOnly.Trim();
                }
                string text = context.FormatType(type);
                context.Print(text);

                EmonicInterpreter.ptypeOutput           = fieldNames;
                EmonicInterpreter.ptypeOutputStaticOnly = fieldNamesStaticOnly;
                EmonicInterpreter.ptypeSem.Release();

                return(text);
            } catch {
                EmonicInterpreter.ptypeOutput           = "--";
                EmonicInterpreter.ptypeOutputStaticOnly = "--";
                EmonicInterpreter.ptypeSem.Release();
                throw;
            }
        }
        public void AssertType(Thread thread, string expression, string exp_result)
        {
            string text = null;

            try {
                ScriptingContext context = GetContext(thread);

                TargetType type = EvaluateExpressionType(context, expression);
                text = context.FormatType(type);
            } catch (AssertionException) {
                throw;
            } catch (Exception ex) {
                Assert.Fail("Failed to evaluate type of expression `{0}': {1}",
                            expression, ex);
            }

            if (text != exp_result)
            {
                Assert.Fail("Type of expression `{0}' is `{1}', but expected `{2}'.",
                            expression, text, exp_result);
            }
        }
Example #21
0
        public void ClearScript_Scripting_RealFs_Test()
        {
            //Assert.Inconclusive(); return;

            Result <string> scriptsPath = FileIO.SearchAFolderAboveTheCurrentDirectoryOfTheApplication(Scripting_TestSettings.ScriptsPath_Tests); // find the folder with the scripts

            if (scriptsPath.IsFailure)
            {
                throw new InvalidOperationException("scripts folder not found");
            }

            ScriptingContext jsScriptingContext = ScriptingContext.ScriptingContextWithRealFs(Path.Combine(scriptsPath.Value, Scripting_TestSettings.ScriptsPath_Tests_ES6));

            JsScriptRunner jsScriptRunner = JsScriptRunner.RunnerWithContext(
                JsScriptRunnerType.ClearScript,
                jsScriptingContext,
                Scripting_TestSettings.ScriptingContextName);

            jsScriptRunner.Run("var exports = {};");                                 // required by the row of 'main.js' ```Object.defineProperty(exports, "__esModule", { value: true });``` generated by TypeScript
            jsScriptRunner.Run(jsScriptingContext.ReadFile("./lib/myrequire.js"));   // load a custom version of 'require'
            jsScriptRunner.Run(jsScriptingContext.ReadFile("main.js"));              // execute script from virtual FS (would have been the same executing "./main.js")
            Assert.AreEqual("Hello World", jsScriptingContext.ReadFile("filename")); // test output of Js scripts
        }
Example #22
0
        public ActionResult Run(string command)
        {
            var context = new ScriptingContext();

            var roslynEngine = new ScriptEngine();

            Roslyn.Scripting.Session session = roslynEngine.CreateSession(context);
            session.AddReference(context.GetType().Assembly);
            session.AddReference("System.Web");
            session.AddReference("System");
            session.AddReference("System.Core");
            session.AddReference("System.Collections");
            session.AddReference("System.Linq");
            session.AddReference("System.Xml");
            session.AddReference("System.Xml.Linq");
            session.ImportNamespace("System");
            session.ImportNamespace("System.IO");
            session.ImportNamespace("System.Linq");
            session.ImportNamespace("System.Xml.Linq");

            var res = session.Execute(command);

            return(View(res));
        }
Example #23
0
        protected override string Execute(ScriptingContext context,
                                          Expression expression, DisplayFormat format)
        {
            try {
                if (expression is TypeExpression)
                {
                    throw new ScriptingException(
                              "`{0}' is a type, not a variable.", expression.Name);
                }
                object retval = expression.Evaluate(context);

                EmonicInterpreter.printData output = new EmonicInterpreter.printData();
                output.type     = "";
                output.varValue = "";
                output.varNames = "";

                if (retval != null)
                {
                    output.type = ((TargetObject)retval).TypeName;
                    if (output.type == null)
                    {
                        output.type = "";
                    }

                    switch (((TargetObject)retval).Kind)
                    {
                    case TargetObjectKind.Fundamental:
                        // we send the value of the fundamental type
                        TargetFundamentalObject tfo = retval as TargetFundamentalObject;
                        if (tfo == null)
                        {
                            // element is "null"
                            output.varValue = "<null>";
                            break;
                        }
                        output.varValue = tfo.GetObject(context.CurrentThread).ToString();
                        if (output.varValue == null)
                        {
                            output.varValue = "";
                        }
                        break;

                    case TargetObjectKind.Array:
                        // we send back the number of array elements
                        TargetArrayObject tao = retval as TargetArrayObject;
                        if (tao == null)
                        {
                            // element is "null"
                            output.varValue = "<null>";
                            break;
                        }
                        int lower = tao.GetLowerBound(context.CurrentThread, 0);
                        int upper = tao.GetUpperBound(context.CurrentThread, 0);
                        output.varNames = (upper - lower).ToString();
                        break;

                    // same for struct and class
                    case TargetObjectKind.Struct:
                    case TargetObjectKind.Class:
                        // we send back the member's names
                        // NOTE! we also show static and constant fields
                        TargetObject obj = retval as TargetObject;
                        if (obj.HasAddress && obj.GetAddress(context.CurrentThread).IsNull)
                        {
                            output.varValue = "<null>";
                            break;
                        }
                        Mono.Debugger.Thread thread = context.CurrentThread;
                        TargetClass          tc     = ((TargetClassObject)retval).Type.GetClass(thread);
                        if (tc == null)
                        {
                            break;
                        }
                        TargetFieldInfo[] tfi = tc.GetFields(thread);
                        if (tfi == null)
                        {
                            break;
                        }
                        output.varNames = "";
                        for (int i = 0; i < tfi.Length; i++)
                        {
                            if (tfi[i].IsStatic)                             // do not show static fields, they're not accessible via the instance!
                            {
                                continue;
                            }
                            output.varNames += tfi[i].Name;
                            output.varNames += " ";
                        }
                        output.varNames = output.varNames.Trim();
                        break;

                    case TargetObjectKind.Object:
                    case TargetObjectKind.Pointer:
                    case TargetObjectKind.Unknown:
                    case TargetObjectKind.Function:
                    case TargetObjectKind.Alias:
                    case TargetObjectKind.Enum:
                        context.Print("ERROR: Print Command will return no values because of an implementation error");
                        break;
                    }
                }
                string text = context.FormatObject(retval, format);
                context.Print(text);

                EmonicInterpreter.printOutput = output;
                EmonicInterpreter.printSem.Release();

                return(text);
            } catch {
                EmonicInterpreter.printData output = new EmonicInterpreter.printData();
                output.type     = "";
                output.varValue = "";
                output.varNames = "";
                EmonicInterpreter.printOutput = output;
                EmonicInterpreter.printSem.Release();
                throw;
            }
        }
Example #24
0
        // copied from the PrintCommand class - we must be able to catch Exceptions here
        protected override bool DoResolve(ScriptingContext context)
        {
            // big try-catch block: we are able to react to Exceptions this way
            // and release the semaphore waiting for the command answer
            try {
                if (Argument.StartsWith("/"))
                {
                    int    pos     = Argument.IndexOfAny(new char[] { ' ', '\t' });
                    string fstring = Argument.Substring(1, pos - 1);
                    string arg     = Argument.Substring(pos + 1);

                    switch (fstring)
                    {
                    case "o":
                    case "object":
                        format = DisplayFormat.Object;
                        break;

                    case "a":
                    case "address":
                        format = DisplayFormat.Address;
                        break;

                    case "x":
                    case "hex":
                        format = DisplayFormat.HexaDecimal;
                        break;

                    case "default":
                        format = DisplayFormat.Default;
                        break;

                    default:
                        throw new ScriptingException(
                                  "Unknown format: `{0}'", fstring);
                    }

                    expression = DoParseExpression(context, arg);
                }
                else
                {
                    expression = ParseExpression(context);
                }

                if (expression == null)
                {
                    return(false);
                }

                if (this is PrintTypeCommand)
                {
                    Expression resolved = expression.TryResolveType(context);
                    if (resolved != null)
                    {
                        expression = resolved;
                        return(true);
                    }
                }

                expression = expression.Resolve(context);
                return(expression != null);
            } catch {
                EmonicInterpreter.ptypeOutput           = "--";
                EmonicInterpreter.ptypeOutputStaticOnly = "--";
                EmonicInterpreter.ptypeSem.Release();
                throw;
            }
        }
Example #25
0
 // copied from PrintCommand class
 protected override object DoExecute(ScriptingContext context)
 {
     return(Execute(context, expression, format));
 }
Example #26
0
 protected override bool DoResolve(ScriptingContext context)
 {
     // do not query "yes or no?", simply quit
     return(true);
 }
Example #27
0
        protected override bool DoResolve(ScriptingContext context)
        {
            // set whole method in a try-catch block: if anything goes wrong, an invalid breakpoint
            // number is set and the semaphore is released.
            try {
                if (global)
                {
                    if (local)
                    {
                        throw new ScriptingException(
                                  "Cannot use both -local and -global.");
                    }

                    if (Group != null)
                    {
                        throw new ScriptingException(
                                  "Cannot use both -group and -global.");
                    }

                    tgroup = ThreadGroup.Global;
                }
                else if (local)
                {
                    if (Group != null)
                    {
                        throw new ScriptingException(
                                  "Cannot use both -group and -local.");
                    }

                    tgroup = context.Interpreter.GetThreadGroup(Group, false);
                }
                else if (Group != null)
                {
                    tgroup = context.Interpreter.GetThreadGroup(Group, false);
                }
                else
                {
                    tgroup = ThreadGroup.Global;
                }

                if (context.Interpreter.HasTarget)
                {
                    context.CurrentProcess = context.Interpreter.GetProcess(p_index);
                    context.CurrentThread  = context.Interpreter.GetThread(t_index);

                    Mono.Debugger.Thread thread = context.CurrentThread;
                    if (!thread.IsStopped)
                    {
                        throw new Mono.Debugger.TargetException(TargetError.NotStopped);
                    }

                    Backtrace backtrace = thread.GetBacktrace();

                    StackFrame frame;
                    if (f_index == -1)
                    {
                        frame = backtrace.CurrentFrame;
                    }
                    else
                    {
                        if (f_index >= backtrace.Count)
                        {
                            throw new ScriptingException(
                                      "No such frame: {0}", f_index);
                        }

                        frame = backtrace [f_index];
                    }

                    context.CurrentFrame = frame;

                    if (ExpressionParser.ParseLocation(
                            thread, thread.CurrentFrame, Argument, out location))
                    {
                        return(true);
                    }
                }

                if (Argument.IndexOf(':') > 0)
                {
                    return(true);
                }

                try {
                    UInt32.Parse(Argument);
                    return(true);
                } catch {
                }

                Expression expr = context.Interpreter.ExpressionParser.Parse(Argument);
                if (expr == null)
                {
                    throw new ScriptingException("Cannot resolve expression `{0}'.", Argument);
                }

                if (expr is PointerExpression)
                {
                    address = ((PointerExpression)expr).EvaluateAddress(context);
                    return(true);
                }

                if (!context.Interpreter.HasTarget)
                {
                    return(true);
                }

                MethodExpression mexpr;
                try {
                    mexpr = expr.ResolveMethod(context, type);
                } catch {
                    if (lazy)
                    {
                        return(true);
                    }
                    throw new ScriptingException("No such method: `{0}'.", Argument);
                }

                if (mexpr != null)
                {
                    location = mexpr.EvaluateSource(context);
                }
                else
                {
                    location = context.FindMethod(Argument);
                }

                if (lazy)
                {
                    return(true);
                }

                if (location == null)
                {
                    throw new ScriptingException("No such method: `{0}'.", Argument);
                }

                return(true);
            } catch {
                EmonicInterpreter.breakpointNumber = -1;
                EmonicInterpreter.breakpointSem.Release();
                throw;
            }
        }
Example #28
0
        // copied that from PrintCommand class - we need that here because we need
        // to know if any exceptions in this method are raised
        protected override bool DoResolve(ScriptingContext context)
        {
            // whole method in a try-catch block - if any exceptions occur, we are able to generate
            // an invalid web service response and release the semaphore
            try {
                if (Argument.StartsWith("/"))
                {
                    int    pos     = Argument.IndexOfAny(new char[] { ' ', '\t' });
                    string fstring = Argument.Substring(1, pos - 1);
                    string arg     = Argument.Substring(pos + 1);

                    switch (fstring)
                    {
                    case "o":
                    case "object":
                        format = DisplayFormat.Object;
                        break;

                    case "a":
                    case "address":
                        format = DisplayFormat.Address;
                        break;

                    case "x":
                    case "hex":
                        format = DisplayFormat.HexaDecimal;
                        break;

                    case "default":
                        format = DisplayFormat.Default;
                        break;

                    default:
                        throw new ScriptingException(
                                  "Unknown format: `{0}'", fstring);
                    }

                    expression = DoParseExpression(context, arg);
                }
                else
                {
                    expression = ParseExpression(context);
                }

                if (expression == null)
                {
                    return(false);
                }

                expression = expression.Resolve(context);
                return(expression != null);
            } catch {
                EmonicInterpreter.printData output = new EmonicInterpreter.printData();
                output.type     = "";
                output.varValue = "";
                output.varNames = "";
                EmonicInterpreter.printOutput = output;
                EmonicInterpreter.printSem.Release();
                throw;
            }
        }
Example #29
0
            protected override object DoExecute(ScriptingContext context)
            {
                int current_id = -1;

                if (context.Interpreter.HasCurrentThread)
                {
                    current_id = context.Interpreter.CurrentThread.ID;
                }

                bool printed_something = false;

                Process[] processes = context.Interpreter.Processes;
                for (int i = 0; i < processes.Length; i++)
                {
                    context.Print("Process {0}:",
                                  context.Interpreter.PrintProcess(processes[i]));

                    Mono.Debugger.Thread[] threads = processes[i].GetThreads();
                    for (int j = 0; j < threads.Length; j++)
                    {
                        string prefix = threads[j].ID == current_id ? "(*)" : "   ";
                        context.Print("{0} {1} ({2}:{3:x}) {4}", prefix, threads[j],
                                      threads[j].PID, threads[j].TID, threads[j].State);
                        printed_something = true;

                        EmonicInterpreter.threadData td = new EmonicInterpreter.threadData();
                        td.processNumber  = processes[i].ID;
                        td.PID            = processes[i].MainThread.PID;
                        td.processCmdLine = context.Interpreter.PrintCommandLineArgs(processes[i]);
                        td.threadNumber   = threads[j].ID;
                        if ((threads[j].ThreadFlags & Mono.Debugger.Thread.Flags.Daemon) != 0)
                        {
                            td.daemonThread = true;
                        }
                        else
                        {
                            td.daemonThread = false;
                        }
                        td.threadState   = threads[j].State != Mono.Debugger.TargetState.Stopped;
                        td.currentThread = threads[j].ID == current_id;
                        td.TID           = threads[j].PID;               // we take the PID of the thread here, not really the TID
                        td.moreData      = j + 1 < threads.Length || i + 1 < processes.Length;

                        EmonicInterpreter.threadList.Add(td);
                    }
                }

                if (!printed_something)
                {
                    context.Print("No target.");

                    // generate an invalid response
                    EmonicInterpreter.threadData td = new EmonicInterpreter.threadData();
                    td.processNumber  = -1;
                    td.PID            = -1;
                    td.processCmdLine = "";
                    td.threadNumber   = -1;
                    td.daemonThread   = false;
                    td.threadState    = false;
                    td.currentThread  = false;
                    td.TID            = -1;
                    td.moreData       = false;
                    EmonicInterpreter.threadList.Add(td);
                }
                return(null);
            }
Example #30
0
        protected override object DoExecute(ScriptingContext context)
        {
            Backtrace backtrace = null;

            if ((mode == Backtrace.Mode.Default) && (max_frames == -1))
            {
                backtrace = CurrentThread.CurrentBacktrace;
            }

            if (backtrace == null)
            {
                backtrace = CurrentThread.GetBacktrace(mode, max_frames);
            }

            for (int i = 0; i < backtrace.Count; i++)
            {
                string prefix = i == backtrace.CurrentFrameIndex ? "(*)" : "   ";
                context.Print("{0} {1}", prefix, backtrace [i]);

                EmonicInterpreter.backtraceData bt = new EmonicInterpreter.backtraceData();
                bt.frameNumber  = backtrace[i].Level;
                bt.currentFrame = i == backtrace.CurrentFrameIndex;
                if (backtrace[i].Method != null)
                {
                    bt.method = backtrace[i].Method.Name;
                    if (bt.method == null)
                    {
                        bt.method = "";
                    }
                }
                else
                {
                    if (backtrace[i].Name == null)
                    {
                        bt.method = "";
                    }
                    else
                    {
                        bt.method = backtrace[i].Name.ToString();
                        if (bt.method == null)
                        {
                            bt.method = "";
                        }
                    }
                }
                if (backtrace[i].SourceAddress != null && backtrace[i].SourceAddress.SourceFile != null)
                {
                    bt.file = backtrace[i].SourceAddress.SourceFile.FileName;
                }
                else
                {
                    bt.file = "";
                }
                if (backtrace[i].SourceAddress != null)
                {
                    bt.lineNumber = backtrace[i].SourceAddress.Row;
                }
                else
                {
                    bt.lineNumber = -1;
                }
                if (i + 1 < backtrace.Count)
                {
                    bt.moreData = true;
                }
                else
                {
                    bt.moreData = false;
                }
                EmonicInterpreter.backtraceList.Add(bt);
            }

            return(backtrace);
        }