Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug#13505: r:neeti@netscape.com. Replace str()'s with nsCRT()'s & nspr()'s.

Browse Source 
git-svn-id: svn://10.0.0.236/trunk@51556 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
pnunn%netscape.com
1999-10-22 21:03:52 +00:00
parent 10a4fb8f22
commit 4be52ad659
10 changed files with 45 additions and 539 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
mozilla/modules/libimg/gifcom/dllcompat.cpp
View File

@@ -28,12 +28,10 @@
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
2> NET_BACat
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "xp_mcom.h"
#include "nsCRT.h"
@@ -65,41 +63,6 @@ int XP_MSG_UNKNOWN = -26;
int XP_MSG_COMPRESS_REMOVE = -27;
PR_END_EXTERN_C
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
char *
NET_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memmove(*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_MALLOC (source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memcpy(*destination, source, source_length);
}
}
return *destination;
}
#if defined(XP_MAC)

41
mozilla/modules/libimg/gifcom/gif.cpp
View File

@@ -63,7 +63,8 @@ mailing address.
#include "prmem.h"
#include "merrors.h"
#include "dllcompat.h"
#include "nsCRT.h"
#include "gif.h"
#include "nsIImgDCallbk.h"
@@ -215,6 +216,42 @@ do {gs->state=gif_gather; gs->gather_request_size = (n); \
/* Get a 32-bit value stored in little-endian format */
#define GETINT32(p) (((p)[3]<<24) | ((p)[2]<<16) | ((p)[1]<<8) | ((p)[0]))
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
char *
il_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memmove(*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_MALLOC (source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memcpy(*destination, source, source_length);
}
}
return *destination;
}
#define BlockAllocCat(dest, dest_length, src, src_length) il_BACat(&(dest), dest_length, src, src_length)
/* Send the data to the display front-end. */
static void
@@ -1487,7 +1524,7 @@ il_gif_write(il_container *ic, const uint8 *buf, int32 len)
/* Shift remaining data to the head of the buffer */
if (gs->gathered && (gs->gather_head != gs->hold)) {
XP_MEMMOVE(gs->hold, gs->gather_head, gs->gathered);
nsCRT::memmove(gs->hold, gs->gather_head, gs->gathered);
gs->gather_head = gs->hold;
}

39
mozilla/modules/libimg/jpgcom/dllcompat.cpp
View File

@@ -28,12 +28,10 @@
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
2> NET_BACat
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "xp_mcom.h"
#include "nsCRT.h"
@@ -64,43 +62,6 @@ int XP_MSG_UNKNOWN = -26;
int XP_MSG_COMPRESS_REMOVE = -27;
PR_END_EXTERN_C
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
char *
NET_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memmove(*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_MALLOC (source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memcpy(*destination, source, source_length);
}
}
return *destination;
}
#if defined(XP_MAC)
/* prototypes for local routines */

3
mozilla/modules/libimg/jpgcom/jpeg.cpp
View File

@@ -18,14 +18,13 @@
/*
* jpeg.c --- Glue code to Independent JPEG Group decoder library
* $Id: jpeg.cpp,v 1.7 1999-10-21 22:22:27 pnunn%netscape.com Exp $
* $Id: jpeg.cpp,v 1.8 1999-10-22 21:01:27 pnunn%netscape.com Exp $
*/
#include "nsIImgDecoder.h" // include if_struct.h Needs to be first
#include "nsIImgDCallbk.h"
//#include "dllcompat.h"
#include "nsCRT.h"
#include "nsJPGDecoder.h"
#include "jpeg.h"

38
mozilla/modules/libimg/pngcom/dllcompat.cpp
View File

@@ -28,12 +28,10 @@
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
2> NET_BACat
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "xp_mcom.h"
#include "nsCRT.h"
@@ -64,42 +62,6 @@ int XP_MSG_UNKNOWN = -26;
int XP_MSG_COMPRESS_REMOVE = -27;
PR_END_EXTERN_C
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
char *
NET_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memmove(*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_MALLOC (source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memcpy(*destination, source, source_length);
}
}
return *destination;
}
#if defined(XP_MAC)

4
mozilla/modules/libimg/public_com/dllcompat.h
View File

@@ -32,10 +32,6 @@
#include "prtypes.h"
#include "nsCom.h"
#include "xp_mcom.h"
#include "xp_str.h"
typedef void
(*TimeoutCallbackFunction) (void * closure);

3
mozilla/modules/libimg/public_com/if_struct.h
View File

@@ -18,7 +18,7 @@
/* if.h --- Top-level image library internal routines
*
* $Id: if_struct.h,v 1.4 1999-05-27 22:40:52 pnunn%netscape.com Exp $
* $Id: if_struct.h,v 1.5 1999-10-22 21:03:09 pnunn%netscape.com Exp $
*/
#ifndef _if_h
@@ -36,7 +36,6 @@
#include "prtime.h"
#include "prlong.h"
#include "dllcompat.h"
#include "nsIImgDecoder.h"
#include "ntypes.h" /* typedefs for commonly used Netscape data

2
mozilla/modules/libimg/src/scale.cpp
View File

@@ -203,7 +203,7 @@ il_flush_image_data(il_container *ic)
/* Update the displayable area of the pixmap. */
ic->displayable_rect.x_origin = 0;
ic->displayable_rect.y_origin = 0;
ic->displayable_rect.width = img_header->width;
ic->displayable_rect.width = (PRUint16)img_header->width;
ic->displayable_rect.height = MAX(ic->displayable_rect.height,
end_row + 1);

395
mozilla/modules/libimg/src/xpcompat.cpp
View File

@@ -25,10 +25,7 @@
* of the XP_ library.
*/
#include "xpcompat.h"
#include "xp_mcom.h"
#include <stdlib.h>
/* BSDI did not have this header and we do not need it here. -slamm */
/* #include <search.h> */
#include "prlog.h"
#include "prmem.h"
#include "plstr.h"
@@ -122,398 +119,8 @@ time_t Mactime(time_t *timer)
}
#endif /* XP_MAC */
/* Allocate a new copy of a block of binary data, and returns it
*/
char *
NET_BACopy (char **destination, const char *source, size_t length)
{
if(*destination)
{
PR_FREEIF(*destination);
*destination = 0;
}
if (! source)
{
*destination = NULL;
}
else
{
*destination = (char *) PR_MALLOC (length);
if (*destination == NULL)
return(NULL);
XP_MEMCPY(*destination, source, length);
}
return *destination;
}
/* binary block Allocate and Concatenate
*
* destination_length is the length of the existing block
* source_length is the length of the block being added to the
* destination block
*/
char *
NET_BACat (char **destination,
size_t destination_length,
const char *source,
size_t source_length)
{
if (source)
{
if (*destination)
{
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memmove(*destination + destination_length, source, source_length);
}
else
{
*destination = (char *) PR_MALLOC (source_length);
if (*destination == NULL)
return(NULL);
nsCRT::memcpy(*destination, source, source_length);
}
}
return *destination;
}
/* Very similar to strdup except it free's too
*/
char *
NET_SACopy (char **destination, const char *source)
{
if(*destination)
{
PR_FREEIF(*destination);
*destination = 0;
}
if (! source)
{
*destination = NULL;
}
else
{
*destination = (char *) PR_MALLOC (PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination, source);
}
return *destination;
}
/* Again like strdup but it concatinates and free's and uses Realloc
*/
char *
NET_SACat (char **destination, const char *source)
{
if (source && *source)
{
if (*destination)
{
int length = PL_strlen (*destination);
*destination = (char *) PR_REALLOC (*destination, length + PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination + length, source);
}
else
{
*destination = (char *) PR_MALLOC (PL_strlen(source) + 1);
if (*destination == NULL)
return(NULL);
PL_strcpy (*destination, source);
}
}
return *destination;
}
#if 0
#include <windows.h>
#include <limits.h>
static void wfe_ProcessTimeouts(DWORD dwNow);
// structure to keep track of FE_SetTimeOut objects
typedef struct WinTimeStruct {
TimeoutCallbackFunction fn;
void * closure;
DWORD dwFireTime;
struct WinTimeStruct * pNext;
} WinTime;
// the one and only list of objects waiting for FE_SetTimeOut
WinTime *gTimeOutList = NULL;
// Process timeouts now.
// Called once per round of fire.
UINT uTimeoutTimer = 0;
DWORD dwNextFire = (DWORD)-1;
DWORD dwSyncHack = 0;
void CALLBACK FireTimeout(HWND hWnd, UINT uMessage, UINT uTimerID, DWORD dwTime)
{
static BOOL bCanEnter = TRUE;
// Don't allow old timer messages in here.
if(uMessage != WM_TIMER) {
PR_ASSERT(0);
return;
}
if(uTimerID != uTimeoutTimer) {
return;
}
// Block only one entry into this function, or else.
if(bCanEnter) {
bCanEnter = FALSE;
// see if we need to fork off any timeout functions
if(gTimeOutList) {
wfe_ProcessTimeouts(dwTime);
}
bCanEnter = TRUE;
}
}
// Function to correctly have the timer be set.
void SyncTimeoutPeriod(DWORD dwTickCount)
{
// May want us to set tick count ourselves.
if(dwTickCount == 0) {
if(dwSyncHack == 0) {
dwTickCount = GetTickCount();
}
else {
dwTickCount = dwSyncHack;
}
}
// If there's no list, we should clear the timer.
if(!gTimeOutList) {
if(uTimeoutTimer) {
::KillTimer(NULL, uTimeoutTimer);
uTimeoutTimer = 0;
dwNextFire = (DWORD)-1;
}
}
else {
// See if we need to clear the current timer.
// Curcumstances are that if the timer will not
// fire on time for the next timeout.
BOOL bSetTimer = FALSE;
WinTime *pTimeout = gTimeOutList;
if(uTimeoutTimer) {
if(pTimeout->dwFireTime != dwNextFire) {
// There is no need to kill the timer if we are just going to set it again.
// Windows will simply respect the new time interval passed in.
::KillTimer(NULL, uTimeoutTimer);
uTimeoutTimer = 0;
dwNextFire = (DWORD)-1;
// Set the timer.
bSetTimer = TRUE;
}
}
else {
// No timer set, attempt.
bSetTimer = TRUE;
}
if(bSetTimer) {
DWORD dwFireWhen = pTimeout->dwFireTime > dwTickCount ?
pTimeout->dwFireTime - dwTickCount : 0;
UINT uFireWhen = (UINT)dwFireWhen;
PR_ASSERT(uTimeoutTimer == 0);
uTimeoutTimer = ::SetTimer(
NULL,
0,
uFireWhen,
(TIMERPROC)FireTimeout);
if(uTimeoutTimer) {
// Set the fire time.
dwNextFire = pTimeout->dwFireTime;
}
}
}
}
/* this function should register a function that will
* be called after the specified interval of time has
* elapsed. This function should return an id
* that can be passed to IL_ClearTimeout to cancel
* the Timeout request.
*
* A) Timeouts never fail to trigger, and
* B) Timeouts don't trigger *before* their nominal timestamp expires, and
* C) Timeouts trigger in the same ordering as their timestamps
*
* After the function has been called it is unregistered
* and will not be called again unless re-registered.
*
* func: The function to be invoked upon expiration of
* the Timeout interval
* closure: Data to be passed as the only argument to "func"
* msecs: The number of milli-seconds in the interval
*/
void *
IL_SetTimeout(TimeoutCallbackFunction func, void * closure, uint32 msecs)
{
WinTime * pTime = new WinTime;
if(!pTime)
return(NULL);
// fill it out
DWORD dwNow = GetTickCount();
pTime->fn = func;
pTime->closure = closure;
pTime->dwFireTime = (DWORD) msecs + dwNow;
//CLM: Always clear this else the last timer added will have garbage!
// (Win16 revealed this bug!)
pTime->pNext = NULL;
// add it to the list
if(!gTimeOutList) {
// no list add it
gTimeOutList = pTime;
} else {
// is it before everything else on the list?
if(pTime->dwFireTime < gTimeOutList->dwFireTime) {
pTime->pNext = gTimeOutList;
gTimeOutList = pTime;
} else {
WinTime * pPrev = gTimeOutList;
WinTime * pCurrent = gTimeOutList;
while(pCurrent && (pCurrent->dwFireTime <= pTime->dwFireTime)) {
pPrev = pCurrent;
pCurrent = pCurrent->pNext;
}
PR_ASSERT(pPrev);
// insert it after pPrev (this could be at the end of the list)
pTime->pNext = pPrev->pNext;
pPrev->pNext = pTime;
}
}
// Sync the timer fire period.
SyncTimeoutPeriod(dwNow);
return(pTime);
}
/* This function cancels a Timeout that has previously been
* set.
* Callers should not pass in NULL or a timer_id that
* has already expired.
*/
void
IL_ClearTimeout(void * pStuff)
{
WinTime * pTimer = (WinTime *) pStuff;
if(!pTimer) {
return;
}
if(gTimeOutList == pTimer) {
// first element in the list lossage
gTimeOutList = pTimer->pNext;
} else {
// walk until no next pointer
for(WinTime * p = gTimeOutList; p && p->pNext && (p->pNext != pTimer); p = p->pNext)
;
// if we found something valid pull it out of the list
if(p && p->pNext && p->pNext == pTimer) {
p->pNext = pTimer->pNext;
} else {
// get out before we delete something that looks bogus
return;
}
}
// if we got here it must have been a valid element so trash it
delete pTimer;
// If there's now no be sure to clear the timer.
SyncTimeoutPeriod(0);
}
//
// Walk down the timeout list and launch anyone appropriate
// Cleaned up logic 04-30-96 GAB
//
static void wfe_ProcessTimeouts(DWORD dwNow)
{
WinTime *p = gTimeOutList;
if(dwNow == 0) {
dwNow = GetTickCount();
}
BOOL bCalledSync = FALSE;
// Set the hack, such that when IL_ClearTimeout
// calls SyncTimeoutPeriod, that GetTickCount()
// overhead is not incurred.
dwSyncHack = dwNow;
// loop over all entries
while(p) {
// send it
if(p->dwFireTime < dwNow) {
// Fire it.
(*p->fn) (p->closure);
// Clear the timer.
// Period synced.
IL_ClearTimeout(p);
bCalledSync = TRUE;
// Reset the loop (can't look at p->pNext now, and called
// code may have added/cleared timers).
// (could do this by going recursive and returning).
p = gTimeOutList;
} else {
// Make sure we fire an timer.
// Also, we need to check to see if things are backing up (they
// may be asking to be fired long before we ever get to them,
// and we don't want to pass in negative values to the real
// timer code, or it takes days to fire....
if(bCalledSync == FALSE) {
SyncTimeoutPeriod(dwNow);
bCalledSync = TRUE;
}
// Get next timer.
p = p->pNext;
}
}
dwSyncHack = 0;
}
#else
NS_EXPORT void*
IL_SetTimeout(TimeoutCallbackFunction func, void * closure, uint32 msecs)
{
@@ -526,5 +133,5 @@ IL_ClearTimeout(void *timer_id)
{
il_ss->ClearTimeout(timer_id);
}
#endif /* XP_PC */

22
mozilla/modules/libimg/src/xpcompat.h
View File

@@ -32,21 +32,12 @@
#include "prtypes.h"
#include "nsCom.h"
/*
* This will probably go away after we stop using 16-bit compilers
* for Win16.
*/
#ifdef XP_WIN16
#define XP_HUGE __huge
#define XP_HUGE_ALLOC(SIZE) halloc(SIZE,1)
#define XP_HUGE_FREE(SIZE) hfree(SIZE)
#define XP_HUGE_MEMCPY(DEST, SOURCE, LEN) hmemcpy(DEST, SOURCE, LEN)
#else
#define XP_HUGE
#define XP_HUGE_ALLOC(SIZE) malloc(SIZE)
#define XP_HUGE_FREE(SIZE) free(SIZE)
#define XP_HUGE_MEMCPY(DEST, SOURCE, LEN) memcpy(DEST, SOURCE, LEN)
#endif
#define XP_HUGE_CHAR_PTR char XP_HUGE *
@@ -73,15 +64,6 @@ extern void XP_QSORT(void *, size_t, size_t,
int (*)(const void *, const void *));
#endif /* XP_MAC */
#define BlockAllocCopy(dest, src, src_length) NET_BACopy((char**)&(dest), src, src_length)
#define BlockAllocCat(dest, dest_length, src, src_length) NET_BACat(&(dest), dest_length, src, src_length)
extern char * NET_BACopy (char **dest, const char *src, size_t src_length);
extern char * NET_BACat (char **dest, size_t dest_length, const char *src, size_t src_length);
extern char * NET_SACopy (char **dest, const char *src);
extern char * NET_SACat (char **dest, const char *src);
NS_EXPORT void* IL_SetTimeout(TimeoutCallbackFunction func, void * closure, uint32 msecs);