Move solution and projects to src

src/Ryujinx.HLE/Exceptions/GuestBrokeExecutionException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class GuestBrokeExecutionException : Exception
+    {
+        private const string ExMsg = "The guest program broke execution!";
+
+        public GuestBrokeExecutionException() : base(ExMsg) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/InternalServiceException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    class InternalServiceException: Exception
+    {
+        public InternalServiceException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/InvalidFirmwarePackageException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    class InvalidFirmwarePackageException : Exception
+    {
+        public InvalidFirmwarePackageException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/InvalidNpdmException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class InvalidNpdmException : Exception
+    {
+        public InvalidNpdmException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/InvalidStructLayoutException.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class InvalidStructLayoutException<T> : Exception 
+    {
+        static readonly Type _structType = typeof(T);
+
+        public InvalidStructLayoutException(string message) : base(message) { }
+        
+        public InvalidStructLayoutException(int expectedSize)
+            : base($"Type {_structType.Name} has the wrong size. Expected: {expectedSize} bytes, got: {Unsafe.SizeOf<T>()} bytes") { }
+    }
+}

src/Ryujinx.HLE/Exceptions/InvalidSystemResourceException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class InvalidSystemResourceException : Exception
+    {
+        public InvalidSystemResourceException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/ServiceNotImplementedException.cs

@@ -0,0 +1,164 @@
+using Ryujinx.Common;
+using Ryujinx.HLE.HOS;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Services;
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    [Serializable]
+    internal class ServiceNotImplementedException : Exception
+    {
+        public IpcService Service { get; }
+        public ServiceCtx Context { get; }
+        public IpcMessage Request { get; }
+
+        public ServiceNotImplementedException(IpcService service, ServiceCtx context)
+            : this(service, context, "The service call is not implemented.") { }
+
+        public ServiceNotImplementedException(IpcService service, ServiceCtx context, string message) : base(message)
+        {
+            Service = service;
+            Context = context;
+            Request = context.Request;
+        }
+
+        public ServiceNotImplementedException(IpcService service, ServiceCtx context, string message, Exception inner) : base(message, inner)
+        {
+            Service = service;
+            Context = context;
+            Request = context.Request;
+        }
+
+        protected ServiceNotImplementedException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+
+        public override string Message
+        {
+            get
+            {
+                return base.Message + Environment.NewLine + Environment.NewLine + BuildMessage();
+            }
+        }
+
+        private string BuildMessage()
+        {
+            StringBuilder sb = new StringBuilder();
+
+            // Print the IPC command details (service name, command ID, and handler)
+            (Type callingType, MethodBase callingMethod) = WalkStackTrace(new StackTrace(this));
+
+            if (callingType != null && callingMethod != null)
+            {
+                // If the type is past 0xF, we are using TIPC
+                var ipcCommands = Request.Type > IpcMessageType.TipcCloseSession ? Service.TipcCommands : Service.CmifCommands;
+
+                // Find the handler for the method called
+                var ipcHandler   = ipcCommands.FirstOrDefault(x => x.Value == callingMethod);
+                var ipcCommandId = ipcHandler.Key;
+                var ipcMethod    = ipcHandler.Value;
+
+                if (ipcMethod != null)
+                {
+                    sb.AppendLine($"Service Command: {Service.GetType().FullName}: {ipcCommandId} ({ipcMethod.Name})");
+                    sb.AppendLine();
+                }
+            }
+
+            sb.AppendLine("Guest Stack Trace:");
+            sb.AppendLine(Context.Thread.GetGuestStackTrace());
+
+            // Print buffer information
+            if (Request.PtrBuff.Count      > 0 ||
+                Request.SendBuff.Count     > 0 ||
+                Request.ReceiveBuff.Count  > 0 ||
+                Request.ExchangeBuff.Count > 0 ||
+                Request.RecvListBuff.Count > 0)
+            {
+                sb.AppendLine("Buffer Information:");
+
+                if (Request.PtrBuff.Count > 0)
+                {
+                    sb.AppendLine("\tPtrBuff:");
+
+                    foreach (var buff in Request.PtrBuff)
+                    {
+                        sb.AppendLine($"\t[{buff.Index}] Position: 0x{buff.Position:x16} Size: 0x{buff.Size:x16}");
+                    }
+                }
+
+                if (Request.SendBuff.Count > 0)
+                {
+                    sb.AppendLine("\tSendBuff:");
+
+                    foreach (var buff in Request.SendBuff)
+                    {
+                        sb.AppendLine($"\tPosition: 0x{buff.Position:x16} Size: 0x{buff.Size:x16} Flags: {buff.Flags}");
+                    }
+                }
+
+                if (Request.ReceiveBuff.Count > 0)
+                {
+                    sb.AppendLine("\tReceiveBuff:");
+
+                    foreach (var buff in Request.ReceiveBuff)
+                    {
+                        sb.AppendLine($"\tPosition: 0x{buff.Position:x16} Size: 0x{buff.Size:x16} Flags: {buff.Flags}");
+                    }
+                }
+
+                if (Request.ExchangeBuff.Count > 0)
+                {
+                    sb.AppendLine("\tExchangeBuff:");
+
+                    foreach (var buff in Request.ExchangeBuff)
+                    {
+                        sb.AppendLine($"\tPosition: 0x{buff.Position:x16} Size: 0x{buff.Size:x16} Flags: {buff.Flags}");
+                    }
+                }
+
+                if (Request.RecvListBuff.Count > 0)
+                {
+                    sb.AppendLine("\tRecvListBuff:");
+
+                    foreach (var buff in Request.RecvListBuff)
+                    {
+                        sb.AppendLine($"\tPosition: 0x{buff.Position:x16} Size: 0x{buff.Size:x16}");
+                    }
+                }
+
+                sb.AppendLine();
+            }
+
+            sb.AppendLine("Raw Request Data:");
+            sb.Append(HexUtils.HexTable(Request.RawData));
+
+            return sb.ToString();
+        }
+
+        private static (Type, MethodBase) WalkStackTrace(StackTrace trace)
+        {
+            int i = 0;
+
+            StackFrame frame;
+
+            // Find the IIpcService method that threw this exception
+            while ((frame = trace.GetFrame(i++)) != null)
+            {
+                var method   = frame.GetMethod();
+                var declType = method.DeclaringType;
+
+                if (typeof(IpcService).IsAssignableFrom(declType))
+                {
+                    return (declType, method);
+                }
+            }
+
+            return (null, null);
+        }
+    }
+}

src/Ryujinx.HLE/Exceptions/TamperCompilationException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class TamperCompilationException : Exception
+    {
+        public TamperCompilationException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/TamperExecutionException.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class TamperExecutionException : Exception
+    {
+        public TamperExecutionException(string message) : base(message) { }
+    }
+}

src/Ryujinx.HLE/Exceptions/UndefinedInstructionException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Ryujinx.HLE.Exceptions
+{
+    public class UndefinedInstructionException : Exception
+    {
+        private const string ExMsg = "The instruction at 0x{0:x16} (opcode 0x{1:x8}) is undefined!";
+
+        public UndefinedInstructionException() : base() { }
+
+        public UndefinedInstructionException(ulong address, int opCode) : base(string.Format(ExMsg, address, opCode)) { }
+    }
+}