kamp/RetroZilla
1
0
Fork 0
mirror of https://github.com/rn10950/RetroZilla.git synced 2024-11-09 09:20:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
9ff0b9c0a2
RetroZilla/build/wince/shunt/stdlib.cpp
Ryan Nematz 2f2ae146c0 first commit
2015-10-20 23:03:22 -04:00

377 lines
8.7 KiB
C++
Raw Blame History

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code, released
* Jan 28, 2003.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 2003
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Garrett Arch Blythe, 28-January-2003
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <string.h>
#include <stdio.h>
#include <windows.h>
#include <aygshell.h>
#include "mozce_internal.h"
#define _MAX_FNAME 256
#define _MAX_DIR _MAX_FNAME
#define _MAX_EXT _MAX_FNAME
extern "C" {
#if 0
}
#endif
// #define LOG_CALLS
MOZCE_SHUNT_API char *mozce_fullpath(char *absPath, const char *relPath, size_t maxLength)
{
MOZCE_PRECHECK
#ifdef LOG_CALLS
#ifdef DEBUG
mozce_printf("mozce_fullpath called\n");
#endif
#endif
if (relPath[0] != '\\')
{
int i;
unsigned short dir[MAX_PATH];
GetModuleFileName(GetModuleHandle (NULL), dir, MAX_PATH);
for (i = _tcslen(dir); i && dir[i] != TEXT('\\'); i--) {}
dir[i + 1] = TCHAR('\0');
w2a_buffer(dir, -1, absPath, maxLength);
}
strcat(absPath, relPath);
return absPath;
}
MOZCE_SHUNT_API void mozce_splitpath(const char* inPath, char* outDrive, char* outDir, char* outFname, char* outExt)
{
MOZCE_PRECHECK
#ifdef LOG_CALLS
#ifdef DEBUG
mozce_printf("mozce_splitpath called\n");
#endif
#endif
if(NULL != outDrive)
{
*outDrive = '\0';
}
if(NULL != outDir)
{
*outDir = '\0';
}
if(NULL != outFname)
{
*outFname = '\0';
}
if(NULL != outExt)
{
*outExt = '\0';
}
if(NULL != inPath && '\0' != *inPath)
{
char* dup = (char*) malloc(strlen(inPath)+1);
if(NULL != dup)
{
strcpy(dup, inPath);
/*
** Change all forward slashes to back.
*/
char* convert = dup;
do
{
if('/' == *convert)
{
*convert = '\\';
}
convert++;
}
while(*convert);
/*
** Find last slash first.
*/
char* slash = strrchr(dup, '\\');
/*
** Find extension, must be after any slash.
*/
char* ext = NULL;
if(NULL == slash)
{
ext = strchr(dup, '.');
}
else
{
ext = strchr(slash, '.');
}
/*
** Reap extension.
*/
if(NULL != ext)
{
if(NULL != outExt)
{
strncpy(outExt, ext, _MAX_EXT);
}
*ext = '\0';
}
/*
** Reap filename.
*/
char* fname = NULL;
if(NULL == slash)
{
fname = dup;
}
else
{
fname = slash + 1;
}
if(NULL != outFname)
{
strncpy(outFname, fname, _MAX_FNAME);
}
*fname = '\0';
/*
** Reap directory.
*/
if(NULL != slash && NULL != outDir)
{
strncpy(outDir, dup, _MAX_DIR);
}
free(dup);
}
}
}
MOZCE_SHUNT_API void mozce_makepath(char* outPath, const char* inDrive, const char* inDir, const char* inFname, const char* inExt)
{
MOZCE_PRECHECK
#ifdef LOG_CALLS
#ifdef DEBUG
mozce_printf("mozce_makepath called\n");
#endif
#endif
if(NULL != outPath)
{
int dirLen = 0;
if(NULL != inDir)
{
dirLen = strlen(inDir);
if(dirLen)
{
dirLen--;
}
}
_snprintf(outPath, _MAX_PATH, "%s%s%s%s%s",
(NULL != inDir) ? inDir : "",
(NULL != inDir && '\\' != inDir[dirLen] && '/' != inDir[dirLen]) ? "\\" : "",
(NULL != inFname) ? inFname : "",
(NULL != inExt && '.' != inExt[0]) ? "." : "",
(NULL != inExt) ? inExt : ""
);
}
}
MOZCE_SHUNT_API int mozce_strcmpi(const char *dest, const char *src)
{
MOZCE_PRECHECK
#ifdef LOG_CALLS
#ifdef DEBUG
mozce_printf("mozce_strcmpi called\n");
#endif
#endif
int f,l;
do {
if ( ((f = (unsigned char)(*(dest++))) >= 'A') && (f <= 'Z') )
f -= ('A' - 'a');
if ( ((l = (unsigned char)(*(src++))) >= 'A') && (l <= 'Z') )
l -= ('A' - 'a');
} while ( f && (f == l) );
return(f - l);
}
static int gDelayBeforeResending = 1000;
static int gFirstRun = 1;
static unsigned long gTotalMemoryAllocated = 0;
static unsigned long gTotalMemoryAllowed = 0;
static unsigned long gLastTickCount = 0;
static void setAllocationUpperLimit()
{
MEMORYSTATUS mst;
mst.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&mst);
gTotalMemoryAllowed = mst.dwAvailPhys / 2; /* XXX should be configurable */
gLastTickCount = GetTickCount() - gDelayBeforeResending;
}
void SendOOMPending()
{
DWORD lastTickCount = GetTickCount();
if (lastTickCount >= gLastTickCount + gDelayBeforeResending)
{
char buffer[4] = "OOM";
COPYDATASTRUCT cds = { 0, 4, buffer };
// XXX The name of this window is Minimo specific.
// Probably should generalize.
HWND a = FindWindowW(L"MINIMO_LISTENER", NULL);
PostMessage(a, WM_COPYDATA, NULL, (LPARAM)&cds);
gLastTickCount = GetTickCount();
}
}
static void memoryCheck()
{
if (gFirstRun)
{
setAllocationUpperLimit();
gFirstRun = 0;
}
if (gTotalMemoryAllocated > gTotalMemoryAllowed)
{
SendOOMPending();
}
}
static void oom()
{
// We can't really do anything else.
SendOOMPending();
}
MOZCE_SHUNT_API void *mozce_malloc(unsigned a)
{
gTotalMemoryAllocated += a;
memoryCheck();
void *buffer = malloc(a);
if (!buffer)
{
SHCloseApps(a);
buffer = malloc(a);
if (!buffer)
oom();
}
return buffer;
}
MOZCE_SHUNT_API void mozce_free(void* a)
{
if (!a)
return;
gTotalMemoryAllocated -= _msize(a);
memoryCheck();
free(a);
}
MOZCE_SHUNT_API void *mozce_realloc(void* a, unsigned b)
{
gTotalMemoryAllocated += b;
gTotalMemoryAllocated -= _msize(a);
memoryCheck();
void *buffer = realloc(a,b);
if (!buffer)
{
SHCloseApps(b);
buffer = realloc(a,b);
if (!buffer)
oom();
}
return buffer;
}
MOZCE_SHUNT_API void *mozce_calloc(size_t n, size_t nelem)
{
gTotalMemoryAllocated += n*nelem;
memoryCheck();
void* buffer = calloc(n, nelem);
if (!buffer)
{
SHCloseApps(n*nelem);
buffer = calloc(n, nelem);
if (!buffer)
oom();
}
return buffer;
}
#if 0
{
#endif
} /* extern "C" */
Reference in New Issue View Git Blame Copy Permalink