Match and link most of Runtime

src/Kyoto/Streams/CMemoryStreamOut.cpp

@@ -0,0 +1,28 @@
+#include "Kyoto/Streams/CMemoryStreamOut.hpp"
+#include "Kyoto/Alloc/CMemory.hpp"
+
+#include <string.h>
+
+CMemoryStreamOut::CMemoryStreamOut(void* buffer, size_t len, EOwnerShip ownerShip, int blockLen)
+: COutputStream(blockLen)
+, mOutPtr(buffer)
+, mOutLength(len)
+, mCurrentPosition(0)
+, mBufferOwned(ownerShip == kOS_Owned) {}
+
+CMemoryStreamOut::~CMemoryStreamOut() {
+  COutputStream::Flush();
+
+  if (mBufferOwned) {
+    delete[] mOutPtr;
+  }
+}
+
+
+void CMemoryStreamOut::Write(const void* ptr, size_t len) {
+  len = (mOutLength - mCurrentPosition) < len ? (mOutLength - mCurrentPosition) : len;
+  if (len != 0) {
+    memcpy(static_cast<uchar*>(mOutPtr) + mCurrentPosition, ptr, len);
+    mCurrentPosition += len;
+  }
+}

src/Kyoto/Streams/CZipInputStream.cpp

@@ -0,0 +1,32 @@
+#include "Kyoto/Streams/CZipInputStream.hpp"
+#include "Kyoto/Streams/CZipSupport.hpp"
+
+CZipInputStream::CZipInputStream(rstl::auto_ptr<CInputStream> in)
+: CInputStream(4096)
+, mCompBuf(new uchar[4096])
+, mStream(in)
+, mZStream(new z_stream_s) {
+  z_stream_s* zs = mZStream.get();
+  zs->next_in = mCompBuf.get();
+  mZStream->avail_in = 0;
+  mZStream->zalloc = CZipSupport::Alloc;
+  mZStream->zfree = CZipSupport::Free;
+  mZStream->opaque = 0;
+  inflateInit2(mZStream.get());
+}
+
+CZipInputStream::~CZipInputStream() {
+  inflateEnd(mZStream.get());
+}
+
+
+size_t CZipInputStream::Read(void* buf, size_t len) {
+  mZStream->next_out = static_cast<Bytef*>(buf);
+  mZStream->avail_out = len;
+  if (mZStream->avail_in == 0) {
+    mZStream->avail_in = mStream->ReadBytes(mCompBuf.get(), 4096);
+    mZStream->next_in = mCompBuf.get();
+  }
+  inflate(mZStream.get(), Z_NO_FLUSH);
+  return len - mZStream->avail_out;
+}

src/Kyoto/Streams/CZipSupport.cpp

@@ -0,0 +1,18 @@
+#include "Kyoto/Streams/CZipSupport.hpp"
+#include "Kyoto/Alloc/CMemory.hpp"
+#include "zlib/zlib.h"
+
+static char* hack() {
+  return ZLIB_VERSION;
+}
+
+void* CZipSupport::Alloc(void* ptr1, uint w1, uint w2) {
+  return new uchar[w1 * w2];
+}
+
+void CZipSupport::Free(void* ptr1, void* ptr2) {
+  if (ptr2 == nullptr) {
+    return;
+  }
+  delete[] ptr2;
+}

src/MetroTRK/mslsupp.c

@@ -1,4 +1,5 @@
 #include "MetroTRK/TrkInit.h"
+#include <stdio.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -11,7 +12,9 @@ void EnableMetroTRKInterrupts() {}
 void InitMetroTRK() {}
 
 // 80003648
-int __read_console() { return 0; }
+int __read_console(__file_handle file, fpos_t* position, int mode, __idle_proc __idle_proc) {
+  return 0;
+}
 
 // 80003650
 int __TRK_write_console() { return 0; }

src/Runtime/ansi_files.c

@@ -0,0 +1,119 @@
+#include "ansi_files.h"
+
+static unsigned char stdin_buff[0x100];
+static unsigned char stdout_buff[0x100];
+static unsigned char stderr_buff[0x100];
+
+extern int fclose(FILE*);
+extern int __read_console(__file_handle file, unsigned char* buff, size_t* count,
+                          __idle_proc idle_proc);
+extern int __write_console(__file_handle file, unsigned char* buff, size_t* count,
+                           __idle_proc idle_proc);
+extern int __close_console(__file_handle file);
+
+FILE __files[4] = {
+    {0,
+     {0, 1, 1, 2, 0},
+     {0, 0, 0, 0},
+     0,
+     0,
+     0,
+     {0, 0},
+     {0, 0},
+     0,
+     stdin_buff,
+     sizeof(stdin_buff),
+     stdin_buff,
+     0,
+     0,
+     0,
+     0,
+     NULL,
+     &__read_console,
+     &__write_console,
+     &__close_console,
+     0,
+     &__files[1]},
+    {1,
+     {0, 2, 1, 2, 0},
+     {0, 0, 0, 0},
+     0,
+     0,
+     0,
+     {0, 0},
+     {0, 0},
+     0,
+     stdout_buff,
+     sizeof(stdout_buff),
+     stdout_buff,
+     0,
+     0,
+     0,
+     0,
+     NULL,
+     &__read_console,
+     &__write_console,
+     &__close_console,
+     0,
+     &__files[2]},
+    {2,
+     {0, 2, 0, 2, 0},
+     {0, 0, 0, 0},
+     0,
+     0,
+     0,
+     {0, 0},
+     {0, 0},
+     0,
+     stderr_buff,
+     sizeof(stderr_buff),
+     stderr_buff,
+     0,
+     0,
+     0,
+     0,
+     NULL,
+     &__read_console,
+     &__write_console,
+     &__close_console,
+     0,
+     &__files[3]},
+};
+
+void __close_all() {
+  FILE* p = &__files[0];
+  FILE* plast;
+
+  // __begin_critical_region(2);
+
+  while (p != NULL) {
+    if (p->mode.file_kind != __closed_file) {
+      fclose(p);
+    }
+
+    plast = p;
+    p = p->next_file_struct;
+    if (plast->is_dynamically_allocated)
+      free(plast);
+    else {
+      plast->mode.file_kind = __unavailable_file;
+      if ((p != NULL) && p->is_dynamically_allocated)
+        plast->next_file_struct = NULL;
+    }
+  }
+
+  // __end_critical_region(2);
+}
+
+int __flush_all() {
+  int retval = 0;
+  FILE* __stream;
+  __stream = &__files[0];
+  while (__stream) {
+    if ((__stream->mode.file_kind) && (fflush(__stream))) {
+      retval = -1;
+    }
+    __stream = __stream->next_file_struct;
+  };
+  return retval;
+}

src/Runtime/buffer_io.c

@@ -0,0 +1,43 @@
+#include "buffer_io.h"
+
+void __convert_from_newlines(unsigned char* buf, size_t* n) {
+}
+
+void __convert_to_newlines(unsigned char* buf, size_t* n) {
+}
+
+void __prep_buffer(FILE* file) {
+  file->buffer_ptr = file->buffer;
+  file->buffer_len = file->buffer_size;
+  file->buffer_len -= file->position & file->buffer_alignment;
+  file->buffer_pos = file->position;
+}
+
+int __flush_buffer(FILE* file, size_t* bytes_flushed) {
+  size_t buffer_len;
+  int ioresult;
+
+  buffer_len = file->buffer_ptr - file->buffer;
+
+  if (buffer_len) {
+    file->buffer_len = buffer_len;
+
+    if (!file->mode.binary_io)
+      __convert_from_newlines(file->buffer, (size_t*)&file->buffer_len);
+
+    ioresult = (*file->write_proc)(file->handle, file->buffer, (size_t*)&file->buffer_len,
+                                   file->idle_proc);
+
+    if (bytes_flushed)
+      *bytes_flushed = file->buffer_len;
+
+    if (ioresult)
+      return (ioresult);
+
+    file->position += file->buffer_len;
+  }
+
+  __prep_buffer(file);
+
+  return 0;
+}

src/Runtime/direct_io.c

@@ -0,0 +1,114 @@
+#include <ansi_files.h>
+#include <stdio.h>
+
+size_t fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) {
+  size_t retval;
+  retval = __fwrite(ptr, memb_size, num_memb, file);
+  return (retval);
+}
+
+size_t __fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) {
+  unsigned char* write_ptr;
+  size_t num_bytes, bytes_to_go, bytes_written;
+  int ioresult, always_buffer;
+
+#ifndef __NO_WIDE_CHAR
+  if (fwide(file, 0) == 0)
+    fwide(file, -1);
+#endif
+
+  bytes_to_go = memb_size * num_memb;
+
+  if (!bytes_to_go || file->state.error || file->mode.file_kind == __closed_file)
+    return 0;
+
+  if (file->mode.file_kind == __console_file)
+    __stdio_atexit();
+
+  always_buffer =
+      !file->mode.binary_io || file->mode.buffer_mode == _IOFBF || file->mode.buffer_mode == _IOLBF;
+
+  if (file->state.io_state == __neutral) {
+    if (file->mode.io_mode & __write) {
+      if (file->mode.io_mode & __append) {
+        if (fseek(file, 0, SEEK_END))
+          return 0;
+      }
+      file->state.io_state = __writing;
+
+      __prep_buffer(file);
+    }
+  }
+
+  if (file->state.io_state != __writing) {
+    set_error(file);
+    return 0;
+  }
+
+  write_ptr = (unsigned char*)ptr;
+  bytes_written = 0;
+
+  if (bytes_to_go && (file->buffer_ptr != file->buffer || always_buffer)) {
+    file->buffer_len = file->buffer_size - (file->buffer_ptr - file->buffer);
+
+    do {
+      unsigned char* newline = NULL;
+
+      num_bytes = file->buffer_len;
+
+      if (num_bytes > bytes_to_go)
+        num_bytes = bytes_to_go;
+      if (file->mode.buffer_mode == _IOLBF && num_bytes)
+        if ((newline = (unsigned char*)__memrchr(write_ptr, '\n', num_bytes)) != NULL)
+          num_bytes = newline + 1 - write_ptr;
+
+      if (num_bytes) {
+        memcpy(file->buffer_ptr, write_ptr, num_bytes);
+
+        write_ptr += num_bytes;
+        bytes_written += num_bytes;
+        bytes_to_go -= num_bytes;
+
+        file->buffer_ptr += num_bytes;
+        file->buffer_len -= num_bytes;
+      }
+      if (!file->buffer_len || newline != NULL ||
+          (file->mode.buffer_mode == _IONBF))
+      {
+        ioresult = __flush_buffer(file, NULL);
+
+        if (ioresult) {
+          set_error(file);
+          bytes_to_go = 0;
+          break;
+        }
+      }
+    } while (bytes_to_go && always_buffer);
+  }
+
+  if (bytes_to_go && !always_buffer) {
+    unsigned char* save_buffer = file->buffer;
+    size_t save_size = file->buffer_size;
+
+    file->buffer = write_ptr;
+    file->buffer_size = bytes_to_go;
+    file->buffer_ptr = write_ptr + bytes_to_go;
+
+    if (__flush_buffer(file, &num_bytes) != __no_io_error)
+      set_error(file);
+
+    bytes_written += num_bytes;
+
+    file->buffer = save_buffer;
+    file->buffer_size = save_size;
+
+    __prep_buffer(file);
+
+    file->buffer_len = 0;
+  }
+
+  if (file->mode.buffer_mode != _IOFBF)
+    file->buffer_len = 0;
+
+  return ((bytes_written + memb_size - 1) / memb_size);
+}

src/Runtime/file_io.c

@@ -0,0 +1,70 @@
+#include "ansi_files.h"
+#include "types.h"
+
+#pragma dont_inline on 
+int fclose(FILE* file) {
+  int flush_result, close_result;
+
+  if (file == nullptr)
+    return (-1);
+  if (file->mode.file_kind == __closed_file)
+    return (0);
+
+  flush_result = fflush(file);
+
+  close_result = (*file->close_proc)(file->handle);
+
+  file->mode.file_kind = __closed_file;
+  file->handle = NULL;
+
+  if (file->state.free_buffer)
+    free(file->buffer);
+  return ((flush_result || close_result) ? -1 : 0);
+}
+
+int fflush(FILE* file) {
+  int pos;
+
+  if (file == nullptr) {
+    return __flush_all();
+  }
+
+  if (file->state.error != 0 || file->mode.file_kind == __closed_file) {
+    return -1;
+  }
+
+  if (file->mode.io_mode == 1) {
+    return 0;
+  }
+
+  if (file->state.io_state >= 3) {
+    file->state.io_state = 2;
+  }
+
+  if (file->state.io_state == 2) {
+    file->buffer_len = 0;
+  }
+
+  if (file->state.io_state != 1) {
+    file->state.io_state = 0;
+    return 0;
+  }
+
+  if (file->mode.file_kind != __disk_file) {
+    pos = 0;
+  } else {
+    pos = ftell(file);
+  }
+
+  if (__flush_buffer(file, 0) != 0) {
+    file->state.error = 1;
+    file->buffer_len = 0;
+    return -1;
+  }
+
+  file->state.io_state = 0;
+  file->position = pos;
+  file->buffer_len = 0;
+  return 0;
+}
+#pragma dont_inline reset