3 files changed, 156 insertions, 4 deletions

diff --git a/src/skel/crossplatform.cpp b/src/skel/crossplatform.cpp
index 577983b6..758125e9 100644
--- a/src/skel/crossplatform.cpp
+++ b/src/skel/crossplatform.cpp
@@ -198,6 +198,20 @@ char* casepath(char const* path, bool checkPathFirst)
     size_t rl = 0;
 
     DIR* d;
+    char* c;
+
+    #if defined(GTA_SWITCH) || defined(GTA_VITA)
+    if( (c = strstr(p, ":/")) != NULL) // scheme used by some environments, eg. switch, vita
+    {
+        size_t deviceNameOffset = c - p + 3;
+        char* deviceNamePath = (char*)alloca(deviceNameOffset + 1);
+        strlcpy(deviceNamePath, p, deviceNameOffset);
+        deviceNamePath[deviceNameOffset] = 0;
+        d = opendir(deviceNamePath);
+        p = c + 1;
+    }
+    else
+    #endif
     if (p[0] == '/' || p[0] == '\\')
     {
         d = opendir("/");
@@ -212,7 +226,7 @@ char* casepath(char const* path, bool checkPathFirst)
 
     bool cantProceed = false; // just convert slashes in what's left in string, don't correct case of letters(because we can't)
     bool mayBeTrailingSlash = false;
-    char* c;
+
     while (c = strsep(&p, "/\\"))
     {
         // May be trailing slash(allow), slash at the start(avoid), or multiple slashes(avoid)
@@ -279,3 +293,133 @@ char* casepath(char const* path, bool checkPathFirst)
     return out;
 }
 #endif
+
+#ifdef GTA_SWITCH
+/* Taken from glibc */
+char *realpath(const char *name, char *resolved)
+{
+   char *rpath, *dest = NULL;
+   const char *start, *end, *rpath_limit;
+   long int path_max;
+
+   /* As per Single Unix Specification V2 we must return an error if
+      either parameter is a null pointer.  We extend this to allow
+      the RESOLVED parameter to be NULL in case the we are expected to
+      allocate the room for the return value.  */
+   if (!name)
+      return NULL;
+
+   /* As per Single Unix Specification V2 we must return an error if
+      the name argument points to an empty string.  */
+   if (name[0] == '\0')
+      return NULL;
+
+#ifdef PATH_MAX
+   path_max = PATH_MAX;
+#else
+   path_max = pathconf(name, _PC_PATH_MAX);
+   if (path_max <= 0)
+      path_max = 1024;
+#endif
+
+   if (!resolved)
+   {
+      rpath = (char*)malloc(path_max);
+      if (!rpath)
+         return NULL;
+   }
+   else
+      rpath = resolved;
+   rpath_limit = rpath + path_max;
+
+   if (name[0] != '/')
+   {
+      if (!getcwd(rpath, path_max))
+      {
+         rpath[0] = '\0';
+         goto error;
+      }
+      dest = (char*)memchr(rpath, '\0', path_max);
+   }
+   else
+   {
+      rpath[0] = '/';
+      dest = rpath + 1;
+   }
+
+   for (start = end = name; *start; start = end)
+   {
+      /* Skip sequence of multiple path-separators.  */
+      while (*start == '/')
+         ++start;
+
+      /* Find end of path component.  */
+      for (end = start; *end && *end != '/'; ++end)
+         /* Nothing.  */;
+
+      if (end - start == 0)
+         break;
+      else if (end - start == 1 && start[0] == '.')
+         /* nothing */;
+      else if (end - start == 2 && start[0] == '.' && start[1] == '.')
+      {
+         /* Back up to previous component, ignore if at root already.  */
+         if (dest > rpath + 1)
+            while ((--dest)[-1] != '/')
+               ;
+      }
+      else
+      {
+         size_t new_size;
+
+         if (dest[-1] != '/')
+            *dest++ = '/';
+
+         if (dest + (end - start) >= rpath_limit)
+         {
+            ptrdiff_t dest_offset = dest - rpath;
+            char *new_rpath;
+
+            if (resolved)
+            {
+               if (dest > rpath + 1)
+                  dest--;
+               *dest = '\0';
+               goto error;
+            }
+            new_size = rpath_limit - rpath;
+            if (end - start + 1 > path_max)
+               new_size += end - start + 1;
+            else
+               new_size += path_max;
+            new_rpath = (char *)realloc(rpath, new_size);
+            if (!new_rpath)
+               goto error;
+            rpath = new_rpath;
+            rpath_limit = rpath + new_size;
+
+            dest = rpath + dest_offset;
+         }
+
+         dest = (char*)memcpy(dest, start, end - start);
+         *dest = '\0';
+      }
+   }
+   if (dest > rpath + 1 && dest[-1] == '/')
+      --dest;
+   *dest = '\0';
+
+   return rpath;
+
+error:
+   if (!resolved)
+      free(rpath);
+   return NULL;
+}
+
+ssize_t readlink (const char * __path, char * __buf, size_t __buflen)
+{
+   errno = ENOSYS;
+   return -1;
+}
+#endif
diff --git a/src/skel/events.cpp b/src/skel/events.cpp
index 3e1e95b3..87447819 100644
--- a/src/skel/events.cpp
+++ b/src/skel/events.cpp
@@ -821,7 +821,9 @@ PadHandler(RsEvent event, void *param)
 RwBool
 AttachInputDevices(void)
 {
+#ifndef IGNORE_MOUSE_KEYBOARD
 	RsInputDeviceAttach(rsKEYBOARD, KeyboardHandler);
+#endif
 
 	RsInputDeviceAttach(rsPAD, PadHandler);
 
diff --git a/src/skel/glfw/glfw.cpp b/src/skel/glfw/glfw.cpp
index 8d3fc7d7..c7f92d34 100644
--- a/src/skel/glfw/glfw.cpp
+++ b/src/skel/glfw/glfw.cpp
@@ -12,12 +12,14 @@ DWORD _dwOperatingSystemVersion;
 #include "resource.h"
 #else
 long _dwOperatingSystemVersion;
+#ifndef GTA_SWITCH
 #ifndef __APPLE__
 #include <sys/sysinfo.h>
 #else
 #include <mach/mach_host.h>
 #include <sys/sysctl.h>
 #endif
+#endif
 #include <errno.h>
 #include <locale.h>
 #include <signal.h>
@@ -51,7 +53,7 @@ long _dwOperatingSystemVersion;
 #include "MemoryMgr.h"
 
 // We found out that GLFW's keyboard input handling is still pretty delayed/not stable, so now we fetch input from X11 directly on Linux.
-#if !defined _WIN32 && !defined __APPLE__ && !defined __SWITCH__ // && !defined WAYLAND
+#if !defined _WIN32 && !defined __APPLE__ && !defined GTA_SWITCH // && !defined WAYLAND
 #define GET_KEYBOARD_INPUT_FROM_X11
 #endif
 
@@ -485,12 +487,14 @@ psInitialize(void)
 	debug("Physical memory size %llu\n", _dwMemAvailPhys);
 	debug("Available physical memory %llu\n", size);
 #else
+#ifndef GTA_SWITCH
  	struct sysinfo systemInfo;
 	sysinfo(&systemInfo);
 	_dwMemAvailPhys = systemInfo.freeram;
 	debug("Physical memory size %u\n", systemInfo.totalram);
 	debug("Available physical memory %u\n", systemInfo.freeram);
 #endif
+#endif
   
   TheText.Unload();
 
@@ -949,13 +953,15 @@ void psPostRWinit(void)
 	RwVideoMode vm;
 	RwEngineGetVideoModeInfo(&vm, GcurSelVM);
 
+	glfwSetFramebufferSizeCallback(PSGLOBAL(window), resizeCB);
+#ifndef IGNORE_MOUSE_KEYBOARD
 #ifndef GET_KEYBOARD_INPUT_FROM_X11
 	glfwSetKeyCallback(PSGLOBAL(window), keypressCB);
 #endif
-	glfwSetFramebufferSizeCallback(PSGLOBAL(window), resizeCB);
 	glfwSetScrollCallback(PSGLOBAL(window), scrollCB);
 	glfwSetCursorPosCallback(PSGLOBAL(window), cursorCB);
 	glfwSetCursorEnterCallback(PSGLOBAL(window), cursorEnterCB);
+#endif
 	glfwSetWindowIconifyCallback(PSGLOBAL(window), windowIconifyCB);
 	glfwSetWindowFocusCallback(PSGLOBAL(window), windowFocusCB);
 	glfwSetJoystickCallback(joysChangeCB);
@@ -1791,7 +1797,7 @@ main(int argc, char *argv[])
 	InitMemoryMgr();
 #endif
 
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(GTA_SWITCH)
 	struct sigaction act;
 	act.sa_sigaction = terminateHandler;
 	act.sa_flags = SA_SIGINFO;