Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-23 17:00:53 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merged winmisc/sdlmisc into osdlib_*.c. (nw)

Browse Source
This commit is contained in:
couriersud 2015-01-25 13:53:11 +01:00
parent 0328251082
commit e8233100c2
11 changed files with 503 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/osd/modules/lib/osdlib_macosx.c
View File

@ -1,4 +1,13 @@
// This file is a placeholder.
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
#include <sys/types.h>
#include <signal.h>
@ -17,6 +26,24 @@
#include "sdlinc.h"
//============================================================
// osd_getenv
//============================================================
char *osd_getenv(const char *name)
{
return getenv(name);
}
//============================================================
// osd_setenv
//============================================================
int osd_setenv(const char *name, const char *value, int overwrite)
{
return setenv(name, value, overwrite);
}
//============================================================
// osd_process_kill
//============================================================
@ -91,24 +118,54 @@ void osd_free(void *ptr)
#endif
}
//============================================================
// osd_getenv
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
char *osd_getenv(const char *name)
void *osd_alloc_executable(size_t size)
{
return getenv(name);
#if defined(SDLMAME_BSD) || defined(SDLMAME_MACOSX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
#elif defined(SDLMAME_UNIX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, 0, 0);
#endif
}
//============================================================
// osd_setenv
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
int osd_setenv(const char *name, const char *value, int overwrite)
void osd_free_executable(void *ptr, size_t size)
{
return setenv(name, value, overwrite);
#ifdef SDLMAME_SOLARIS
munmap((char *)ptr, size);
#else
munmap(ptr, size);
#endif
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
#ifdef MAME_DEBUG
printf("MAME exception: %s\n", message);
printf("Attempting to fall into debugger\n");
kill(getpid(), SIGTRAP);
#else
printf("Ignoring MAME exception: %s\n", message);
#endif
}
//============================================================
// PROTOTYPES
//============================================================
@ -177,7 +234,7 @@ static osd_ticks_t mach_cycle_counter(void)
}
//============================================================
// osd_cycles
// osd_ticks
//============================================================
osd_ticks_t osd_ticks(void)
@ -225,4 +282,3 @@ void osd_sleep(osd_ticks_t duration)
usleep(msec*1000);
}
}

289
src/osd/modules/lib/osdlib_os2.c
View File

@ -1,4 +1,291 @@
// This file is a placeholder.
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
// standard sdl header
#include "sdlinc.h"
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/stat.h>
#define INCL_DOS
#include <os2.h>
// MAME headers
#include "osdcore.h"
#include "osdlib.h"
//============================================================
// osd_getenv
//============================================================
char *osd_getenv(const char *name)
{
return getenv(name);
}
//============================================================
// osd_setenv
//============================================================
int osd_setenv(const char *name, const char *value, int overwrite)
{
return setenv(name, value, overwrite);
}
//============================================================
// osd_process_kill
//============================================================
void osd_process_kill(void)
{
fprintf(stderr,"osd_process_kill missing in OS/2 build\n");
}
//============================================================
// osd_num_processors
//============================================================
int osd_get_num_processors(void)
{
ULONG numprocs = 1;
DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &numprocs, sizeof(numprocs));
return numprocs;
}
//============================================================
// osd_malloc
//============================================================
void *osd_malloc(size_t size)
{
#ifndef MALLOC_DEBUG
return malloc(size);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_malloc_array
//============================================================
void *osd_malloc_array(size_t size)
{
#ifndef MALLOC_DEBUG
return malloc(size);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_free
//============================================================
void osd_free(void *ptr)
{
#ifndef MALLOC_DEBUG
free(ptr);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
void *p;
DosAllocMem( &p, size, fALLOC );
return p;
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
DosFreeMem( ptr );
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
printf("Ignoring MAME exception: %s\n", message);
}
//============================================================
// PROTOTYPES
//============================================================
static osd_ticks_t init_cycle_counter(void);
static osd_ticks_t performance_cycle_counter(void);
//============================================================
// STATIC VARIABLES
//============================================================
// global cycle_counter function and divider
static osd_ticks_t (*cycle_counter)(void) = init_cycle_counter;
static osd_ticks_t (*ticks_counter)(void) = init_cycle_counter;
static osd_ticks_t ticks_per_second;
//============================================================
// init_cycle_counter
//
// to avoid total grossness, this function is split by subarch
//============================================================
static osd_ticks_t init_cycle_counter(void)
{
osd_ticks_t start, end;
osd_ticks_t a, b;
ULONG frequency;
PTIB ptib;
ULONG ulClass;
ULONG ulDelta;
DosGetInfoBlocks( &ptib, NULL );
ulClass = HIBYTE( ptib->tib_ptib2->tib2_ulpri );
ulDelta = LOBYTE( ptib->tib_ptib2->tib2_ulpri );
if ( DosTmrQueryFreq( &frequency ) == 0 )
{
// use performance counter if available as it is constant
cycle_counter = performance_cycle_counter;
ticks_counter = performance_cycle_counter;
ticks_per_second = frequency;
// return the current cycle count
return (*cycle_counter)();
}
else
{
fprintf(stderr, "No Timer available!\n");
exit(-1);
}
// temporarily set our priority higher
DosSetPriority( PRTYS_THREAD, PRTYC_TIMECRITICAL, PRTYD_MAXIMUM, 0 );
// wait for an edge on the timeGetTime call
a = SDL_GetTicks();
do
{
b = SDL_GetTicks();
} while (a == b);
// get the starting cycle count
start = (*cycle_counter)();
// now wait for 1/4 second total
do
{
a = SDL_GetTicks();
} while (a - b < 250);
// get the ending cycle count
end = (*cycle_counter)();
// compute ticks_per_sec
ticks_per_second = (end - start) * 4;
// restore our priority
DosSetPriority( PRTYS_THREAD, ulClass, ulDelta, 0 );
// return the current cycle count
return (*cycle_counter)();
}
//============================================================
// performance_cycle_counter
//============================================================
static osd_ticks_t performance_cycle_counter(void)
{
QWORD qwTime;
DosTmrQueryTime( &qwTime );
return (osd_ticks_t)qwTime.ulLo;
}
//============================================================
// osd_ticks
//============================================================
osd_ticks_t osd_ticks(void)
{
return (*cycle_counter)();
}
//============================================================
// osd_ticks_per_second
//============================================================
osd_ticks_t osd_ticks_per_second(void)
{
if (ticks_per_second == 0)
{
// if we haven't computed the value yet, there's no time like the present
init_cycle_counter();
}
return ticks_per_second;
}
//============================================================
// osd_sleep
//============================================================
void osd_sleep(osd_ticks_t duration)
{
UINT32 msec;
// make sure we've computed ticks_per_second
if (ticks_per_second == 0)
(void)osd_ticks();
// convert to milliseconds, rounding down
msec = (UINT32)(duration * 1000 / ticks_per_second);
// only sleep if at least 2 full milliseconds
if (msec >= 2)
{
// take a couple of msecs off the top for good measure
msec -= 2;
usleep(msec*1000);
}
}

82
src/osd/modules/lib/osdlib_unix.c
View File

@ -1,3 +1,13 @@
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
#include <stdlib.h>
#include <unistd.h>
@ -32,6 +42,15 @@ int osd_setenv(const char *name, const char *value, int overwrite)
return setenv(name, value, overwrite);
}
//============================================================
// osd_process_kill
//============================================================
void osd_process_kill(void)
{
kill(getpid(), SIGKILL);
}
//============================================================
// osd_num_processors
//============================================================
@ -46,15 +65,6 @@ int osd_get_num_processors(void)
return processors;
}
//============================================================
// osd_process_kill
//============================================================
void osd_process_kill(void)
{
kill(getpid(), SIGKILL);
}
//============================================================
// osd_malloc
//============================================================
@ -97,7 +107,54 @@ void osd_free(void *ptr)
}
//============================================================
// osd_cycles
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
#if defined(SDLMAME_BSD) || defined(SDLMAME_MACOSX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
#elif defined(SDLMAME_UNIX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, 0, 0);
#endif
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
#ifdef SDLMAME_SOLARIS
munmap((char *)ptr, size);
#else
munmap(ptr, size);
#endif
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
#ifdef MAME_DEBUG
printf("MAME exception: %s\n", message);
printf("Attempting to fall into debugger\n");
kill(getpid(), SIGTRAP);
#else
printf("Ignoring MAME exception: %s\n", message);
#endif
}
//============================================================
// osd_ticks
//============================================================
osd_ticks_t osd_ticks(void)
@ -115,6 +172,11 @@ osd_ticks_t osd_ticks(void)
#endif
}
//============================================================
// osd_ticks_per_second
//============================================================
osd_ticks_t osd_ticks_per_second(void)
{
return (osd_ticks_t) 1000000;

89
src/osd/modules/lib/osdlib_win32.c
View File

@ -1,6 +1,11 @@
//============================================================
//
// winos.c - Win32 OS specific low level code
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
@ -18,6 +23,8 @@
#include "osdcomm.h"
#include "osdcore.h"
#include "winutf8.h"
//============================================================
// MACROS
//============================================================
@ -28,20 +35,15 @@
// align allocations to start or end of the page?
#define GUARD_ALIGN_START 0
//============================================================
// osd_num_processors
// GLOBAL VARIABLES
//============================================================
int osd_get_num_processors(void)
{
SYSTEM_INFO info;
#ifdef OSD_WINDOWS
void (*s_debugger_stack_crawler)() = NULL;
#endif
// otherwise, fetch the info from the system
GetSystemInfo(&info);
// max out at 4 for now since scaling above that seems to do poorly
return MIN(info.dwNumberOfProcessors, 4);
}
//============================================================
// osd_getenv
@ -52,6 +54,7 @@ char *osd_getenv(const char *name)
return getenv(name);
}
//============================================================
// osd_setenv
//============================================================
@ -86,6 +89,21 @@ void osd_process_kill(void)
TerminateProcess(GetCurrentProcess(), -1);
}
//============================================================
// osd_num_processors
//============================================================
int osd_get_num_processors(void)
{
SYSTEM_INFO info;
// otherwise, fetch the info from the system
GetSystemInfo(&info);
// max out at 4 for now since scaling above that seems to do poorly
return MIN(info.dwNumberOfProcessors, 4);
}
//============================================================
// osd_malloc
//============================================================
@ -168,6 +186,54 @@ void osd_free(void *ptr)
}
//============================================================
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
VirtualFree(ptr, 0, MEM_RELEASE);
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
#ifdef OSD_WINDOWS
if (IsDebuggerPresent())
{
win_output_debug_string_utf8(message);
DebugBreak();
}
else if (s_debugger_stack_crawler != NULL)
(*s_debugger_stack_crawler)();
#else
if (IsDebuggerPresent())
{
OutputDebugStringA(message);
DebugBreak();
}
#endif
}
//============================================================
// GLOBAL VARIABLES
//============================================================
@ -228,7 +294,6 @@ osd_ticks_t osd_ticks_per_second(void)
return ticks_per_second;
}
//============================================================
// osd_sleep
//============================================================

1
src/osd/sdl/sdl.mak
View File

@ -411,7 +411,6 @@ OSDCOREOBJS = \
$(SDLOBJ)/sdlfile.o \
$(SDLOBJ)/sdlptty_$(BASE_TARGETOS).o \
$(SDLOBJ)/sdlsocket.o \
$(SDLOBJ)/sdlmisc_$(BASE_TARGETOS).o \
$(SDLOBJ)/sdlos_$(SDLOS_TARGETOS).o \
$(OSDOBJ)/modules/lib/osdlib_$(SDLOS_TARGETOS).o \
$(OSDOBJ)/modules/sync/sync_$(SYNC_IMPLEMENTATION).o \

59
src/osd/sdl/sdlmisc_os2.c
View File

@ -1,59 +0,0 @@
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
// standard sdl header
#include "sdlinc.h"
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#define INCL_DOS
#include <os2.h>
// MAME headers
#include "osdcore.h"
//============================================================
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
void *p;
DosAllocMem( &p, size, fALLOC );
return p;
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
DosFreeMem( ptr );
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
printf("Ignoring MAME exception: %s\n", message);
}

66
src/osd/sdl/sdlmisc_unix.c
View File

@ -1,66 +0,0 @@
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
#include <sys/mman.h>
#include <signal.h>
#ifdef MAME_DEBUG
#include <unistd.h>
#endif
// MAME headers
#include "osdcore.h"
//============================================================
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
#if defined(SDLMAME_BSD) || defined(SDLMAME_MACOSX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
#elif defined(SDLMAME_UNIX)
return (void *)mmap(0, size, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, 0, 0);
#endif
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
#ifdef SDLMAME_SOLARIS
munmap((char *)ptr, size);
#else
munmap(ptr, size);
#endif
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
#ifdef MAME_DEBUG
printf("MAME exception: %s\n", message);
printf("Attempting to fall into debugger\n");
kill(getpid(), SIGTRAP);
#else
printf("Ignoring MAME exception: %s\n", message);
#endif
}

56
src/osd/sdl/sdlmisc_win32.c
View File

@ -1,56 +0,0 @@
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// Copyright (c) 1996-2010, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
// standard sdl header
#include "sdlinc.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
// MAME headers
#include "osdcore.h"
//============================================================
// osd_alloc_executable
//
// allocates "size" bytes of executable memory. this must take
// things like NX support into account.
//============================================================
void *osd_alloc_executable(size_t size)
{
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
}
//============================================================
// osd_free_executable
//
// frees memory allocated with osd_alloc_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
VirtualFree(ptr, 0, MEM_RELEASE);
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
if (IsDebuggerPresent())
{
OutputDebugStringA(message);
DebugBreak();
}
}

222
src/osd/sdl/sdlos_os2.c
View File

@ -23,227 +23,7 @@
// MAME headers
#include "osdcore.h"
//============================================================
// PROTOTYPES
//============================================================
static osd_ticks_t init_cycle_counter(void);
static osd_ticks_t performance_cycle_counter(void);
//============================================================
// STATIC VARIABLES
//============================================================
// global cycle_counter function and divider
static osd_ticks_t (*cycle_counter)(void) = init_cycle_counter;
static osd_ticks_t (*ticks_counter)(void) = init_cycle_counter;
static osd_ticks_t ticks_per_second;
//============================================================
// init_cycle_counter
//
// to avoid total grossness, this function is split by subarch
//============================================================
static osd_ticks_t init_cycle_counter(void)
{
osd_ticks_t start, end;
osd_ticks_t a, b;
ULONG frequency;
PTIB ptib;
ULONG ulClass;
ULONG ulDelta;
DosGetInfoBlocks( &ptib, NULL );
ulClass = HIBYTE( ptib->tib_ptib2->tib2_ulpri );
ulDelta = LOBYTE( ptib->tib_ptib2->tib2_ulpri );
if ( DosTmrQueryFreq( &frequency ) == 0 )
{
// use performance counter if available as it is constant
cycle_counter = performance_cycle_counter;
ticks_counter = performance_cycle_counter;
ticks_per_second = frequency;
// return the current cycle count
return (*cycle_counter)();
}
else
{
fprintf(stderr, "No Timer available!\n");
exit(-1);
}
// temporarily set our priority higher
DosSetPriority( PRTYS_THREAD, PRTYC_TIMECRITICAL, PRTYD_MAXIMUM, 0 );
// wait for an edge on the timeGetTime call
a = SDL_GetTicks();
do
{
b = SDL_GetTicks();
} while (a == b);
// get the starting cycle count
start = (*cycle_counter)();
// now wait for 1/4 second total
do
{
a = SDL_GetTicks();
} while (a - b < 250);
// get the ending cycle count
end = (*cycle_counter)();
// compute ticks_per_sec
ticks_per_second = (end - start) * 4;
// restore our priority
DosSetPriority( PRTYS_THREAD, ulClass, ulDelta, 0 );
// return the current cycle count
return (*cycle_counter)();
}
//============================================================
// performance_cycle_counter
//============================================================
static osd_ticks_t performance_cycle_counter(void)
{
QWORD qwTime;
DosTmrQueryTime( &qwTime );
return (osd_ticks_t)qwTime.ulLo;
}
//============================================================
// osd_cycles
//============================================================
osd_ticks_t osd_ticks(void)
{
return (*cycle_counter)();
}
//============================================================
// osd_ticks_per_second
//============================================================
osd_ticks_t osd_ticks_per_second(void)
{
if (ticks_per_second == 0)
{
// if we haven't computed the value yet, there's no time like the present
init_cycle_counter();
}
return ticks_per_second;
}
//============================================================
// osd_sleep
//============================================================
void osd_sleep(osd_ticks_t duration)
{
UINT32 msec;
// make sure we've computed ticks_per_second
if (ticks_per_second == 0)
(void)osd_ticks();
// convert to milliseconds, rounding down
msec = (UINT32)(duration * 1000 / ticks_per_second);
// only sleep if at least 2 full milliseconds
if (msec >= 2)
{
// take a couple of msecs off the top for good measure
msec -= 2;
usleep(msec*1000);
}
}
//============================================================
// osd_num_processors
//============================================================
int osd_get_num_processors(void)
{
ULONG numprocs = 1;
DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &numprocs, sizeof(numprocs));
return numprocs;
}
//============================================================
// osd_malloc
//============================================================
void *osd_malloc(size_t size)
{
#ifndef MALLOC_DEBUG
return malloc(size);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_malloc_array
//============================================================
void *osd_malloc_array(size_t size)
{
#ifndef MALLOC_DEBUG
return malloc(size);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_free
//============================================================
void osd_free(void *ptr)
{
#ifndef MALLOC_DEBUG
free(ptr);
#else
#error "MALLOC_DEBUG not yet supported"
#endif
}
//============================================================
// osd_getenv
//============================================================
char *osd_getenv(const char *name)
{
return getenv(name);
}
//============================================================
// osd_setenv
//============================================================
int osd_setenv(const char *name, const char *value, int overwrite)
{
return setenv(name, value, overwrite);
}
#include "osdlib.h"
//============================================================
// osd_get_clipboard_text

1
src/osd/windows/windows.mak
View File

@ -349,7 +349,6 @@ OSDCOREOBJS = \
$(WINOBJ)/strconv.o \
$(WINOBJ)/windir.o \
$(WINOBJ)/winfile.o \
$(WINOBJ)/winmisc.o \
$(OSDOBJ)/modules/sync/sync_windows.o \
$(WINOBJ)/winutf8.o \
$(WINOBJ)/winutil.o \

63
src/osd/windows/winmisc.c
View File

@ -1,63 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
//============================================================
//
// winmisc.c - Win32 OSD core miscellaneous functions
//
//============================================================
// standard windows headers
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>
// MAME headers
#include "osdcore.h"
// MAMEOS headers
#include "winutf8.h"
#include "strconv.h"
#include "strconv.h"
//============================================================
// GLOBAL VARIABLES
//============================================================
void (*s_debugger_stack_crawler)() = NULL;
//============================================================
// osd_alloc_executable
//============================================================
void *osd_alloc_executable(size_t size)
{
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
}
//============================================================
// osd_free_executable
//============================================================
void osd_free_executable(void *ptr, size_t size)
{
VirtualFree(ptr, 0, MEM_RELEASE);
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
if (IsDebuggerPresent())
{
win_output_debug_string_utf8(message);
DebugBreak();
}
else if (s_debugger_stack_crawler != NULL)
(*s_debugger_stack_crawler)();
}