Merge branch 'develop' of https://github.com/EvilBeaver/OneScript into develop

Author: EvilBeaver

src/VSCode.DebugAdapter/DebugeeProcess.cs

@@ -26,7 +26,7 @@ internal abstract class DebugeeProcess
         private bool _stdoutEOF;
         private bool _stderrEOF;
         private bool _attachMode;
-        
+
         private Encoding _dapEncoding;
 
         private OneScriptDebuggerClient _debugger;
@@ -41,9 +41,22 @@ public DebugeeProcess(PathHandlingStrategy pathHandling)
         {
             _strategy = pathHandling;
         }
-        
-        public bool HasExited => _process?.HasExited ?? true;
-        public int ExitCode => _process.ExitCode;
+
+        public bool HasExited
+        {
+            get
+            {
+                if (_process != null)
+                    return _process.HasExited;
+
+                if (_attachMode && _debugger != null)
+                    return false;
+                    
+                return true;
+            }
+        }
+
+        public int ExitCode => _process?.ExitCode ?? 0;
 
         public int DebugPort { get; set; }
 
@@ -56,14 +69,16 @@ public int ProtocolVersion
                 _activeProtocolVersion = value;
             }
         }
-        
+
         public bool WaitOnStart { get; set; }
 
+        public WorkspaceMapper PathsMapper { get; set; }
+
         public void Start()
         {
             _process = CreateProcess();
             var psi = _process.StartInfo;
-            
+
             psi.RedirectStandardError = true;
             psi.RedirectStandardOutput = true;
 
@@ -83,21 +98,57 @@ public void Start()
             _process.BeginOutputReadLine();
             _process.BeginErrorReadLine();
         }
-        
+
         public void InitAttached()
         {
             var pid = _debugger.GetProcessId();
-            _process = Process.GetProcessById(pid);
+
+            try
+            {
+                _process = Process.GetProcessById(pid);
+                _process.EnableRaisingEvents = true;
+                _process.Exited += Process_Exited;
+            }
+            catch
+            {
+                _process = null;
+            }
+
             _attachMode = true;
-            _process.EnableRaisingEvents = true;
-            _process.Exited += Process_Exited;
+
         }
-        
+
         public void Init(JObject args)
         {
             InitInternal(args);
         }
-        
+
+        public void InitPathsMapper(JObject args)
+        {
+            if (args == null)
+            {
+                PathsMapper = null;
+                return;
+            }
+
+            try
+            {
+                var mappingToken = args["pathsMapping"];
+                if (mappingToken == null || mappingToken.Type == JTokenType.Null)
+                {
+                    PathsMapper = null;
+                    return;
+                }
+
+                PathsMapper = mappingToken.ToObject<WorkspaceMapper>();
+            }
+            catch (Exception ex)
+            {
+                Log.Warning(ex, "Failed to initialize paths mapper; path mapping will be disabled");
+                PathsMapper = null;
+            }
+        }
+
         protected abstract Process CreateProcess();
 
         protected abstract void InitInternal(JObject args);
@@ -106,12 +157,12 @@ protected string ConvertClientPathToDebugger(string clientPath)
         {
             return _strategy.ConvertClientPathToDebugger(clientPath);
         }
-        
+
         protected void LoadEnvironment(ProcessStartInfo psi, IDictionary<string, string> variables)
         {
             if (variables == null || variables.Count <= 0)
                 return;
-            
+
             foreach (var pair in variables)
             {
                 psi.EnvironmentVariables[pair.Key] = pair.Value;
@@ -128,7 +179,7 @@ protected void SetEncoding(string encodingFromOptions)
             {
                 _dapEncoding = Utilities.GetEncodingFromOptions(encodingFromOptions);
             }
-            
+
             Log.Information("Encoding for debuggee output is {Encoding}", _dapEncoding);
         }
 
@@ -142,10 +193,10 @@ public void SetClient(OneScriptDebuggerClient service)
             _debugger = service;
             ProtocolVersion = service.ProtocolVersion;
         }
-        
+
         public event EventHandler<DebugeeOutputEventArgs> OutputReceived;
         public event EventHandler ProcessExited;
-        
+
         private void Process_Exited(object sender, EventArgs e)
         {
             _debugger?.Stop();
@@ -194,7 +245,7 @@ private void Terminate()
                 {
                     System.Threading.Thread.Sleep(100);
                 }
-                
+
                 _terminated = true;
                 _process = null;
                 _debugger = null;
@@ -211,7 +262,7 @@ public void HandleDisconnect(bool terminate)
             _debugger.Disconnect(terminate);
 
             var mustKill = terminate && !_attachMode;
-            
+
             if (mustKill && _process != null && !_process.HasExited)
             {
                 Log.Debug("Stopping child process...");
@@ -225,12 +276,15 @@ public void HandleDisconnect(bool terminate)
                     Log.Debug("Process killed");
                 }
             }
-            
+
             Log.Debug("Debuggee disconnected");
         }
 
         public void Kill()
         {
+            if (_process == null)
+                return;
+
             _process.Kill();
             _process.WaitForExit(1500);
         }
@@ -259,30 +313,48 @@ public void SetExceptionsBreakpoints((string Id, string Condition)[] filters)
 
         public Breakpoint[] SetBreakpoints(IEnumerable<Breakpoint> breakpoints)
         {
-            var confirmedBreaks = _debugger.SetMachineBreakpoints(breakpoints.ToArray());
-            
+            var breakpointsArray = breakpoints.ToArray();
+
+            if (PathsMapper != null)
+            {
+                for (int i = 0; i < breakpointsArray.Length; i++)
+                {
+                    breakpointsArray[i].Source = PathsMapper.LocalToRemote(breakpointsArray[i].Source);
+                }
+            }
+
+            var confirmedBreaks = _debugger.SetMachineBreakpoints(breakpointsArray);
+
             return confirmedBreaks;
         }
 
         public void BeginExecution(int threadId)
         {
             _debugger.Execute(threadId);
         }
-        
+
         public StackFrame[] GetStackTrace(int threadId, int firstFrameIdx, int limit)
         {
             var allFrames = _debugger.GetStackFrames(threadId);
-            
+            var pathsMapperInit = PathsMapper != null;
+
             if (limit == 0)
                 limit = allFrames.Length;
 
-            if(allFrames.Length < firstFrameIdx)
+            if (allFrames.Length < firstFrameIdx)
                 return new StackFrame[0];
 
             var result = new List<StackFrame>();
             for (int i = firstFrameIdx; i < limit && i < allFrames.Length; i++)
             {
+
                 allFrames[i].ThreadId = threadId;
+
+                if (pathsMapperInit)
+                {
+                    allFrames[i].Source = PathsMapper.RemoteToLocal(allFrames[i].Source);
+                }
+
                 result.Add(allFrames[i]);
             }
 

src/VSCode.DebugAdapter/OscriptDebugSession.cs

@@ -35,7 +35,7 @@ public override void Initialize(Response response, dynamic args)
             LogCommandReceived();
             AdapterID = (string) args.adapterID;
 
-            _debuggee = DebugeeFactory.CreateProcess(AdapterID, PathStrategy);
+            _debuggee = DebugeeFactory.CreateProcess(AdapterID, PathStrategy);      
 
             SendResponse(response, new Capabilities
             {
@@ -137,7 +137,9 @@ public override void Attach(Response response, dynamic arguments)
         {
             LogCommandReceived();
             SubscribeForDebuggeeProcessEvents();
+
             _debuggee.DebugPort = GetFromContainer(arguments, "debugPort", 2801);
+            _debuggee.InitPathsMapper(arguments);  
 
             DebugClientFactory debugClientFactory;
             try

src/VSCode.DebugAdapter/WorkspaceMapper.cs

@@ -0,0 +1,88 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the 
+Mozilla Public License, v.2.0. If a copy of the MPL 
+was not distributed with this file, You can obtain one 
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+using System;
+using System.Runtime.InteropServices;
+using Newtonsoft.Json;
+
+namespace VSCode.DebugAdapter
+{
+    public class WorkspaceMapper
+    {
+
+        private Workspace _localWorkspace;
+        private Workspace _remoteWorkspace;
+
+        [JsonProperty("localPath")]
+        private string LocalPathForDeserialization
+        {
+            set { _localWorkspace = new Workspace(value ?? ""); }
+        }
+
+        [JsonProperty("remotePath")]
+        private string RemotePathForDeserialization
+        {
+            set { _remoteWorkspace = new Workspace(value ?? ""); }
+        }
+
+        public WorkspaceMapper(){}
+        
+        public WorkspaceMapper(string localPath, string remotePath) {
+            
+			this._localWorkspace = new Workspace(localPath);
+			this._remoteWorkspace = new Workspace(remotePath);
+		}
+
+        public string LocalToRemote(string path)
+        {
+           return ConvertPath(path, _localWorkspace, _remoteWorkspace); 
+        }
+
+        public string RemoteToLocal(string path)
+        {
+           return ConvertPath(path, _remoteWorkspace, _localWorkspace);
+        }
+
+        private string ConvertPath(string path, Workspace fromPrefix, Workspace toPrefix)
+        {
+            if (string.IsNullOrWhiteSpace(path) || 
+                string.IsNullOrWhiteSpace(fromPrefix.Original) || 
+                string.IsNullOrWhiteSpace(toPrefix.Original))
+                return path;
+
+            var normalizedPath = path.Replace('\\', '/');
+            var normalizedFrom = fromPrefix.Normalized;
+            
+            var comparison = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                ? StringComparison.OrdinalIgnoreCase
+                : StringComparison.Ordinal;
+
+            if (normalizedPath.StartsWith(toPrefix.Normalized, comparison) ||
+                !normalizedPath.StartsWith(normalizedFrom, comparison))
+                return path;
+
+            var relativePath = normalizedPath.Substring(normalizedFrom.Length).TrimStart('/');          
+            var result = toPrefix.Normalized + "/" + relativePath;
+            
+            return result;
+        }
+           
+    }
+
+    internal class Workspace
+    {
+        public string Original;
+        public string Normalized;
+
+        internal Workspace(string path)
+        {
+            this.Original = path;
+            this.Normalized = path.Replace('\\', '/').TrimEnd('/');
+        }
+
+    }
+
+}

src/VSCode.DebugAdapter/package.json

@@ -132,7 +132,25 @@
                 "type": "string",
                 "description": "Кодировка вывода отлаживаемого приложения. Отладчик будет интерпретировать вывод приложения в указанной кодировке",
                 "default": ""
+              },
+              "pathsMapping": {
+                "type": "object",
+                "description": "Сопоставление путей между локальной и удаленной машиной (для удаленной отладки)",
+                "properties": {
+                  "localPath": {
+                    "type": "string",
+                    "description": "Путь к каталогу проекта на локальной машине.",
+                    "default": ""
+                  },
+                  "remotePath": {
+                    "type": "string",
+                    "description": "Путь к каталогу проекта на удаленной машине.",
+                    "default": ""
+                  }
+                },
+                "required": ["localPath", "remotePath"]
               }
+
             }
           }
         }