changed most Sys_Error calls to Con_Printf with appropriate error returns

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@5458 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/cl_particles.c b/cl_particles.c
index 2e5d5259c6cdd0160499f71b9301243440d5994d..235a5424f4f58418b8d99d90f7fc9a11e489eed4 100644 (file)
--- a/cl_particles.c
+++ b/cl_particles.c
@@ -78,11 +78,17 @@ void fractalnoise(qbyte *noise, int size, int startgrid)
 
        for (sizepower = 0;(1 << sizepower) < size;sizepower++);
        if (size != (1 << sizepower))
-               Sys_Error("fractalnoise: size must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: size must be power of 2\n");
+               return;
+       }
 
        for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++);
        if (startgrid != (1 << gridpower))
-               Sys_Error("fractalnoise: grid must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: grid must be power of 2\n");
+               return;
+       }
 
        startgrid = bound(0, startgrid, size);
 

diff --git a/cmd.c b/cmd.c
index 40d1b72d40afd524ed665e1c02a6033faaebe07e..0a6459743b36b8ad65f5d08ed62c749d29ddf5f0 100644 (file)
--- a/cmd.c
+++ b/cmd.c
@@ -557,14 +557,16 @@ static void Cmd_TokenizeString (const char *text)
                {
                        l = strlen(com_token) + 1;
                        if (cmd_tokenizebufferpos + l > CMD_TOKENIZELENGTH)
-                               Sys_Error("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
+                       {
+                               Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
+                               break;
+                       }
                        strcpy (cmd_tokenizebuffer + cmd_tokenizebufferpos, com_token);
                        cmd_argv[cmd_argc] = cmd_tokenizebuffer + cmd_tokenizebufferpos;
                        cmd_tokenizebufferpos += l;
                        cmd_argc++;
                }
        }
-
 }
 
 
@@ -904,7 +906,10 @@ int Cmd_CheckParm (const char *parm)
        int i;
 
        if (!parm)
-               Sys_Error ("Cmd_CheckParm: NULL");
+       {
+               Con_Printf ("Cmd_CheckParm: NULL");
+               return 0;
+       }
 
        for (i = 1; i < Cmd_Argc (); i++)
                if (!strcasecmp (parm, Cmd_Argv (i)))

diff --git a/fractalnoise.c b/fractalnoise.c
index 06d00db0eedbc805291b94771b13178d17bbcc42..90419e3d4e4d4a3574aa5460f82545b05eab6440 100644 (file)
--- a/fractalnoise.c
+++ b/fractalnoise.c
@@ -9,11 +9,17 @@ void fractalnoise(qbyte *noise, int size, int startgrid)
 
        for (sizepower = 0;(1 << sizepower) < size;sizepower++);
        if (size != (1 << sizepower))
-               Sys_Error("fractalnoise: size must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: size must be power of 2\n");
+               return;
+       }
 
        for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++);
        if (startgrid != (1 << gridpower))
-               Sys_Error("fractalnoise: grid must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: grid must be power of 2\n");
+               return;
+       }
 
        startgrid = bound(0, startgrid, size);
 
@@ -72,11 +78,17 @@ void fractalnoisequick(qbyte *noise, int size, int startgrid)
 
        for (sizepower = 0;(1 << sizepower) < size;sizepower++);
        if (size != (1 << sizepower))
-               Sys_Error("fractalnoise: size must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: size must be power of 2\n");
+               return;
+       }
 
        for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++);
        if (startgrid != (1 << gridpower))
-               Sys_Error("fractalnoise: grid must be power of 2\n");
+       {
+               Con_Printf("fractalnoise: grid must be power of 2\n");
+               return;
+       }
 
        startgrid = bound(0, startgrid, size);
 

diff --git a/fs.c b/fs.c
index 2d53dbddc43cc9c735bd91e15913c73d459763d1..930a694a8d8f9496260a9166955d01f97fde5d3c 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -539,17 +539,29 @@ pack_t *FS_LoadPackPK3 (const char *packfile)
                return NULL;
 
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
-               Sys_Error ("%s is not a PK3 file", packfile);
+       {
+               Con_Printf ("%s is not a PK3 file", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        // Multi-volume ZIP archives are NOT allowed
        if (eocd.disknum != 0 || eocd.cdir_disknum != 0)
-               Sys_Error ("%s is a multi-volume ZIP archive", packfile);
+       {
+               Con_Printf ("%s is a multi-volume ZIP archive", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        // We only need to do this test if MAX_FILES_IN_PACK is lesser than 65535
        // since eocd.nbentries is an unsigned 16 bits integer
 #if MAX_FILES_IN_PACK < 65535
        if (eocd.nbentries > MAX_FILES_IN_PACK)
-               Sys_Error ("%s contains too many files (%hu)", packfile, eocd.nbentries);
+       {
+               Con_Printf ("%s contains too many files (%hu)", packfile, eocd.nbentries);
+               close(packhandle);
+               return NULL;
+       }
 #endif
 
        // Create a package structure in memory
@@ -564,7 +576,12 @@ pack_t *FS_LoadPackPK3 (const char *packfile)
 
        real_nb_files = PK3_BuildFileList (pack, &eocd);
        if (real_nb_files < 0)
-               Sys_Error ("%s is not a valid PK3 file", packfile);
+       {
+               Con_Printf ("%s is not a valid PK3 file", packfile);
+               close(pack->handle);
+               Mem_Free(pack);
+               return NULL;
+       }
 
        Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
        return pack;
@@ -578,25 +595,29 @@ PK3_GetTrueFileOffset
 Find where the true file data offset is
 ====================
 */
-void PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
+qboolean PK3_GetTrueFileOffset (packfile_t *pfile, pack_t *pack)
 {
        qbyte buffer [ZIP_LOCAL_CHUNK_BASE_SIZE];
        size_t count;
 
        // Already found?
        if (pfile->flags & PACKFILE_FLAG_TRUEOFFS)
-               return;
+               return true;
 
        // Load the local file description
        lseek (pack->handle, pfile->offset, SEEK_SET);
        count = read (pack->handle, buffer, ZIP_LOCAL_CHUNK_BASE_SIZE);
        if (count != ZIP_LOCAL_CHUNK_BASE_SIZE || BuffBigLong (buffer) != ZIP_DATA_HEADER)
-               Sys_Error ("Can't retrieve file %s in package %s", pfile->name, pack->filename);
+       {
+               Con_Printf ("Can't retrieve file %s in package %s", pfile->name, pack->filename);
+               return false;
+       }
 
        // Skip name and extra field
        pfile->offset += BuffLittleShort (&buffer[26]) + BuffLittleShort (&buffer[28]) + ZIP_LOCAL_CHUNK_BASE_SIZE;
 
        pfile->flags |= PACKFILE_FLAG_TRUEOFFS;
+       return true;
 }
 
 
@@ -638,8 +659,7 @@ static packfile_t* FS_AddFileToPack (const char* name, pack_t* pack,
 
                // If we found the file, there's a problem
                if (!diff)
-                       Sys_Error ("Package %s contains the file %s several times\n",
-                                          pack->filename, name);
+                       Con_Printf ("Package %s contains the file %s several times\n", pack->filename, name);
 
                // If we're too far in the list
                if (diff > 0)
@@ -732,17 +752,29 @@ pack_t *FS_LoadPackPAK (const char *packfile)
                return NULL;
        read (packhandle, (void *)&header, sizeof(header));
        if (memcmp(header.id, "PACK", 4))
-               Sys_Error ("%s is not a packfile", packfile);
+       {
+               Con_Printf ("%s is not a packfile", packfile);
+               close(packhandle);
+               return NULL;
+       }
        header.dirofs = LittleLong (header.dirofs);
        header.dirlen = LittleLong (header.dirlen);
 
        if (header.dirlen % sizeof(dpackfile_t))
-               Sys_Error ("%s has an invalid directory size", packfile);
+       {
+               Con_Printf ("%s has an invalid directory size", packfile);
+               close(packhandle);
+               return NULL;
+       }
 
        numpackfiles = header.dirlen / sizeof(dpackfile_t);
 
        if (numpackfiles > MAX_FILES_IN_PACK)
-               Sys_Error ("%s has %i files", packfile, numpackfiles);
+       {
+               Con_Printf ("%s has %i files", packfile, numpackfiles);
+               close(packhandle);
+               return NULL;
+       }
 
        pack = Mem_Alloc(fs_mempool, sizeof (pack_t));
        pack->ignorecase = false; // PAK is case sensitive
@@ -948,13 +980,21 @@ void FS_Init (void)
                        {
                                search->pack = FS_LoadPackPAK (com_argv[i]);
                                if (!search->pack)
-                                       Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
+                               {
+                                       Con_Printf ("Couldn't load packfile: %s", com_argv[i]);
+                                       Mem_Free(search);
+                                       continue;
+                               }
                        }
                        else if (!strcasecmp (FS_FileExtension (com_argv[i]), "pk3"))
                        {
                                search->pack = FS_LoadPackPK3 (com_argv[i]);
                                if (!search->pack)
-                                       Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
+                               {
+                                       Con_Printf ("Couldn't load packfile: %s", com_argv[i]);
+                                       Mem_Free(search);
+                                       continue;
+                               }
                        }
                        else
                                strlcpy (search->filename, com_argv[i], sizeof (search->filename));
@@ -1117,9 +1157,12 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
 
        pfile = &pack->files[pack_ind];
 
+       fs_filesize = -1;
+
        // If we don't have the true offset, get it now
        if (! (pfile->flags & PACKFILE_FLAG_TRUEOFFS))
-               PK3_GetTrueFileOffset (pfile, pack);
+               if (!PK3_GetTrueFileOffset (pfile, pack))
+                       return NULL;
 
        // No Zlib DLL = no compressed files
        if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
@@ -1127,13 +1170,24 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                Con_Printf("WARNING: can't open the compressed file %s\n"
                                        "You need the Zlib DLL to use compressed files\n",
                                        pfile->name);
-               fs_filesize = -1;
+               return NULL;
+       }
+
+       // LordHavoc: lseek affects all duplicates of a handle so we do it before
+       // the dup() call to avoid having to close the dup_handle on error here
+       if (lseek (pack->handle, pfile->offset, SEEK_SET) == -1)
+       {
+               Con_Printf ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)",
+                                       pfile->name, pack->filename, pfile->offset);
                return NULL;
        }
 
        dup_handle = dup (pack->handle);
        if (dup_handle < 0)
-               Sys_Error ("FS_OpenPackedFile: can't dup package's handle (pack: %s)", pack->filename);
+       {
+               Con_Printf ("FS_OpenPackedFile: can't dup package's handle (pack: %s)", pack->filename);
+               return NULL;
+       }
 
        file = Mem_Alloc (fs_mempool, sizeof (*file));
        memset (file, 0, sizeof (*file));
@@ -1144,10 +1198,6 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
        file->position = 0;
        file->ungetc = EOF;
 
-       if (lseek (file->handle, file->offset, SEEK_SET) == -1)
-               Sys_Error ("FS_OpenPackedFile: can't lseek to %s in %s (offset: %d)",
-                                       pfile->name, pack->filename, file->offset);
-
        if (pfile->flags & PACKFILE_FLAG_DEFLATED)
        {
                ztoolkit_t *ztk;
@@ -1173,7 +1223,12 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                 * size of both compressed and uncompressed data
                 */
                if (qz_inflateInit2 (&ztk->zstream, -MAX_WBITS) != Z_OK)
-                       Sys_Error ("FS_OpenPackedFile: inflate init error (file: %s)", pfile->name);
+               {
+                       Con_Printf ("FS_OpenPackedFile: inflate init error (file: %s)", pfile->name);
+                       close(dup_handle);
+                       Mem_Free(file);
+                       return NULL;
+               }
 
                ztk->zstream.next_out = file->buff;
                ztk->zstream.avail_out = sizeof (file->buff);
@@ -1555,7 +1610,10 @@ size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
                                count = sizeof (ztk->input);
                        lseek (file->handle, file->offset + ztk->in_position, SEEK_SET);
                        if (read (file->handle, ztk->input, count) != (ssize_t)count)
-                               Sys_Error ("FS_Read: unexpected end of file");
+                       {
+                               Con_Printf ("FS_Read: unexpected end of file");
+                               break;
+                       }
 
                        ztk->in_ind = 0;
                        ztk->in_len = count;
@@ -1575,7 +1633,10 @@ size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
                        ztk->zstream.avail_out = sizeof (file->buff);
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
-                               Sys_Error ("Can't inflate file");
+                       {
+                               Con_Printf ("FS_Read: Can't inflate file");
+                               break;
+                       }
                        ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
 
                        file->buff_len = sizeof (file->buff) - ztk->zstream.avail_out;
@@ -1594,7 +1655,10 @@ size_t FS_Read (qfile_t* file, void* buffer, size_t buffersize)
                        ztk->zstream.avail_out = buffersize;
                        error = qz_inflate (&ztk->zstream, Z_SYNC_FLUSH);
                        if (error != Z_OK && error != Z_STREAM_END)
-                               Sys_Error ("Can't inflate file");
+                       {
+                               Con_Printf ("FS_Read: Can't inflate file");
+                               break;
+                       }
                        ztk->in_ind = ztk->in_len - ztk->zstream.avail_in;
 
                        // How much data did it inflate?

diff --git a/gl_draw.c b/gl_draw.c
index 3c1c394bda53ebc37fe5738f9aa5769d26c31304..d1dbbf4a27b75641411fa97df2d4024e3ee3ff6e 100644 (file)
--- a/gl_draw.c
+++ b/gl_draw.c
@@ -310,7 +310,11 @@ cachepic_t *Draw_CachePic (const char *path, qboolean persistent)
                        return pic;
 
        if (numcachepics == MAX_CACHED_PICS)
-               Sys_Error ("numcachepics == MAX_CACHED_PICS");
+       {
+               Con_Printf ("Draw_CachePic: numcachepics == MAX_CACHED_PICS");
+               // FIXME: support NULL in callers?
+               return cachepics; // return the first one
+       }
        pic = cachepics + (numcachepics++);
        strlcpy (pic->name, path, sizeof(pic->name));
        // link into list
@@ -400,7 +404,11 @@ cachepic_t *Draw_NewPic(const char *picname, int width, int height, int alpha, q
                if (pic == NULL)
                {
                        if (numcachepics == MAX_CACHED_PICS)
-                               Sys_Error ("numcachepics == MAX_CACHED_PICS");
+                       {
+                               Con_Printf ("Draw_NewPic: numcachepics == MAX_CACHED_PICS");
+                               // FIXME: support NULL in callers?
+                               return cachepics; // return the first one
+                       }
                        pic = cachepics + (numcachepics++);
                        strcpy (pic->name, picname);
                        // link into list

diff --git a/gl_textures.c b/gl_textures.c
index 4288f3da8c41045413176dd1bf8e676499fc5a32..c0493bd86d79740bb9d33885477e47ef4b8c8a81 100644 (file)
--- a/gl_textures.c
+++ b/gl_textures.c
@@ -283,7 +283,7 @@ void R_FreeTexturePool(rtexturepool_t **rtexturepool)
        while (pool->gltchain)
                R_FreeTexture((rtexture_t *)pool->gltchain);
        if (pool->imagechain)
-               Sys_Error("R_FreeTexturePool: not all images freed\n");
+               Con_Printf("R_FreeTexturePool: not all images freed\n");
        Mem_Free(pool);
 }
 
@@ -928,7 +928,10 @@ static void R_FindImageForTexture(gltexture_t *glt)
 
                image = Mem_Alloc(texturemempool, sizeof(gltextureimage_t));
                if (image == NULL)
-                       Sys_Error("R_FindImageForTexture: ran out of memory\n");
+               {
+                       Con_Printf ("R_FindImageForTexture: ran out of memory\n");
+                       return;
+               }
                image->type = GLIMAGETYPE_FRAGMENTS;
                // make sure the created image is big enough for the fragment
                for (image->width = block_size;image->width < glt->width;image->width <<= 1);
@@ -953,7 +956,10 @@ static void R_FindImageForTexture(gltexture_t *glt)
 
                image = Mem_Alloc(texturemempool, sizeof(gltextureimage_t));
                if (image == NULL)
-                       Sys_Error("R_FindImageForTexture: ran out of memory\n");
+               {
+                       Con_Printf ("R_FindImageForTexture: ran out of memory\n");
+                       return;
+               }
                image->type = GLIMAGETYPE_TILE;
                image->blockallocation = NULL;
 
@@ -1018,16 +1024,28 @@ static rtexture_t *R_SetupTexture(rtexturepool_t *rtexturepool, const char *iden
                return NULL;
 
        if (flags & TEXF_FRAGMENT && texturetype != GLTEXTURETYPE_2D)
-               Sys_Error("R_LoadTexture: only 2D fragment textures implemented\n");
+       {
+               Con_Printf ("R_LoadTexture: only 2D fragment textures implemented\n");
+               return NULL;
+       }
        if (texturetype == GLTEXTURETYPE_CUBEMAP && !gl_texturecubemap)
-               Sys_Error("R_LoadTexture: cubemap texture not supported by driver\n");
+       {
+               Con_Printf ("R_LoadTexture: cubemap texture not supported by driver\n");
+               return NULL;
+       }
        if (texturetype == GLTEXTURETYPE_3D && !gl_texture3d)
-               Sys_Error("R_LoadTexture: 3d texture not supported by driver\n");
+       {
+               Con_Printf ("R_LoadTexture: 3d texture not supported by driver\n");
+               return NULL;
+       }
 
        texinfo = R_GetTexTypeInfo(textype, flags);
        size = width * height * depth * sides * texinfo->inputbytesperpixel;
        if (size < 1)
-               Sys_Error("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides);
+       {
+               Con_Printf ("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides);
+               return NULL;
+       }
 
        // clear the alpha flag if the texture has no transparent pixels
        switch(textype)
@@ -1095,8 +1113,9 @@ static rtexture_t *R_SetupTexture(rtexturepool_t *rtexturepool, const char *iden
        {
                glt->inputtexels = Mem_Alloc(texturemempool, size);
                if (glt->inputtexels == NULL)
-                       Sys_Error("R_LoadTexture: out of memory\n");
-               memcpy(glt->inputtexels, data, size);
+                       Con_Printf ("R_LoadTexture: out of memory\n");
+               else
+                       memcpy(glt->inputtexels, data, size);
        }
        else
                glt->inputtexels = NULL;

diff --git a/host.c b/host.c
index 2436c3e782d7f459817fd7d4b443a16abd7603bf..d2d22bbaa3a6a5cd5035d663a18a9e9e20efe14b 100644 (file)
--- a/host.c
+++ b/host.c
@@ -176,7 +176,7 @@ void Host_ServerOptions (void)
                if (i && i + 1 < com_argc && atoi (com_argv[i+1]) >= 1)
                        svs.maxclients = atoi (com_argv[i+1]);
                if (COM_CheckParm ("-listen"))
-                       Sys_Error ("Only one of -dedicated or -listen can be specified");
+                       Con_Printf ("Only one of -dedicated or -listen can be specified");
                // default sv_public on for dedicated servers (often hosted by serious administrators), off for listen servers (often hosted by clueless users)
                Cvar_SetValue("sv_public", 1);
        }

diff --git a/image.c b/image.c
index ebed474304d363f9e75d7af9a7d5169247d0dea2..4e372a85aea5dbf3e2dd04a918ebb61ef0fd1b1e 100644 (file)
--- a/image.c
+++ b/image.c
@@ -1303,7 +1303,10 @@ Image_Resample
 void Image_Resample (const void *indata, int inwidth, int inheight, int indepth, void *outdata, int outwidth, int outheight, int outdepth, int bytesperpixel, int quality)
 {
        if (indepth != 1 || outdepth != 1)
-               Sys_Error("Image_Resample: 3D resampling not supported\n");
+       {
+               Con_Printf ("Image_Resample: 3D resampling not supported\n");
+               return;
+       }
        if (bytesperpixel == 4)
        {
                if (quality)
@@ -1319,7 +1322,7 @@ void Image_Resample (const void *indata, int inwidth, int inheight, int indepth,
                        Image_Resample24Nolerp(indata, inwidth, inheight, outdata, outwidth, outheight);
        }
        else
-               Sys_Error("Image_Resample: unsupported bytesperpixel %i\n", bytesperpixel);
+               Con_Printf ("Image_Resample: unsupported bytesperpixel %i\n", bytesperpixel);
 }
 
 // in can be the same as out
@@ -1327,7 +1330,10 @@ void Image_MipReduce(const qbyte *in, qbyte *out, int *width, int *height, int *
 {
        int x, y, nextrow;
        if (*depth != 1 || destdepth != 1)
-               Sys_Error("Image_Resample: 3D resampling not supported\n");
+       {
+               Con_Printf ("Image_Resample: 3D resampling not supported\n");
+               return;
+       }
        nextrow = *width * bytesperpixel;
        if (*width > destwidth)
        {
@@ -1368,7 +1374,7 @@ void Image_MipReduce(const qbyte *in, qbyte *out, int *width, int *height, int *
                                }
                        }
                        else
-                               Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+                               Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
                }
                else
                {
@@ -1403,7 +1409,7 @@ void Image_MipReduce(const qbyte *in, qbyte *out, int *width, int *height, int *
                                }
                        }
                        else
-                               Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+                               Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
                }
        }
        else
@@ -1444,10 +1450,10 @@ void Image_MipReduce(const qbyte *in, qbyte *out, int *width, int *height, int *
                                }
                        }
                        else
-                               Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+                               Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
                }
                else
-                       Sys_Error("Image_MipReduce: desired size already achieved\n");
+                       Con_Printf ("Image_MipReduce: desired size already achieved\n");
        }
 }
 

diff --git a/keys.c b/keys.c
index c23c294564b86ee1aa3631dc8e63d41676aace71..cfd62813b12f54082f7c580aa333416093d12a04 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -859,7 +859,7 @@ Key_Event (int key, char ascii, qboolean down)
                                if(UI_Callback_IsSlotUsed(key_dest - 3))
                                        UI_Callback_KeyDown (key, ascii);
                                else
-                                       Sys_Error ("Bad key_dest");
+                                       Con_Printf ("Key_Event: Bad key_dest");
                }
                return;
        }
@@ -924,7 +924,7 @@ Key_Event (int key, char ascii, qboolean down)
                        if(UI_Callback_IsSlotUsed(key_dest - 3))
                                UI_Callback_KeyDown (key, ascii);
                        else
-                               Sys_Error ("Bad key_dest");
+                               Con_Printf ("Key_Event: Bad key_dest");
        }
 }
 

diff --git a/netconn.c b/netconn.c
index 429d20b70f9e9724281fe51084af70bab03ab61e..870f694f2083d27055aa82bf8037f5994a132926 100755 (executable)
--- a/netconn.c
+++ b/netconn.c
@@ -440,13 +440,22 @@ int NetConn_SendReliableMessage(netconn_t *conn, sizebuf_t *data)
 
 //#ifdef DEBUG
        if (data->cursize == 0)
-               Sys_Error("Datagram_SendMessage: zero length message\n");
+       {
+               Con_Printf ("Datagram_SendMessage: zero length message\n");
+               return -1;
+       }
 
        if (data->cursize > (int)sizeof(conn->sendMessage))
-               Sys_Error("Datagram_SendMessage: message too big (%u > %u)\n", data->cursize, sizeof(conn->sendMessage));
+       {
+               Con_Printf ("Datagram_SendMessage: message too big (%u > %u)\n", data->cursize, sizeof(conn->sendMessage));
+               return -1;
+       }
 
        if (conn->canSend == false)
-               Sys_Error("SendMessage: called with canSend == false\n");
+       {
+               Con_Printf ("SendMessage: called with canSend == false\n");
+               return -1;
+       }
 //#endif
 
        memcpy(conn->sendMessage, data->data, data->cursize);
@@ -571,10 +580,16 @@ int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data)
 
 //#ifdef DEBUG
        if (data->cursize == 0)
-               Sys_Error("Datagram_SendUnreliableMessage: zero length message\n");
+       {
+               Con_Printf ("Datagram_SendUnreliableMessage: zero length message\n");
+               return -1;
+       }
 
        if (packetLen > (int)sizeof(sendbuffer))
-               Sys_Error("Datagram_SendUnreliableMessage: message too big %u\n", data->cursize);
+       {
+               Con_Printf ("Datagram_SendUnreliableMessage: message too big %u\n", data->cursize);
+               return -1;
+       }
 //#endif
 
        header = (void *)sendbuffer;

diff --git a/r_modules.c b/r_modules.c
index fc0186a3e852e50fe4b71a8992fa9bb5785dc30e..e3729796bad69bd58f1c884e5fa5292fed3a4d30 100644 (file)
--- a/r_modules.c
+++ b/r_modules.c
@@ -28,7 +28,10 @@ void R_RegisterModule(char *name, void(*start)(void), void(*shutdown)(void), voi
                if (rendermodule[i].name == NULL)
                        break;
                if (!strcmp(name, rendermodule[i].name))
-                       Sys_Error("R_RegisterModule: module \"%s\" registered twice\n", name);
+               {
+                       Con_Printf("R_RegisterModule: module \"%s\" registered twice\n", name);
+                       return;
+               }
        }
        if (i >= MAXRENDERMODULES)
                Sys_Error("R_RegisterModule: ran out of renderer module slots (%i)\n", MAXRENDERMODULES);
@@ -47,7 +50,10 @@ void R_Modules_Start(void)
                if (rendermodule[i].name == NULL)
                        continue;
                if (rendermodule[i].active)
-                       Sys_Error("R_StartModules: module \"%s\" already active\n", rendermodule[i].name);
+               {
+                       Con_Printf ("R_StartModules: module \"%s\" already active\n", rendermodule[i].name);
+                       continue;
+               }
                rendermodule[i].active = 1;
                rendermodule[i].start();
        }

diff --git a/snd_main.c b/snd_main.c
index a4717f43521314d5c7ace491a928db9b28c2a391..365ebf85cc0affeb4fbd6da0c254bec8a73180af 100644 (file)
--- a/snd_main.c
+++ b/snd_main.c
@@ -303,7 +303,10 @@ void S_FreeSfx (sfx_t *sfx, qboolean force)
                                break;
                        }
                if (prev_sfx == NULL)
-                       Sys_Error ("S_FreeSfx: Can't find SFX %s in the list!\n", sfx->name);
+               {
+                       Con_Printf ("S_FreeSfx: Can't find SFX %s in the list!\n", sfx->name);
+                       return;
+               }
        }
 
        // Free it

diff --git a/snd_mem.c b/snd_mem.c
index 07c32eb1865d4c1f780dd89e2e73cea311e64455..2b061f454330b6a5ab1d830cf1e60ff55f38ec5c 100644 (file)
--- a/snd_mem.c
+++ b/snd_mem.c
@@ -69,8 +69,11 @@ size_t ResampleSfx (const qbyte *in_data, size_t in_length, const snd_format_t*
 
                // Check that we can handle one second of that sound
                if (in_format->speed * in_format->channels > (1 << INTEGER_BITS))
-                       Sys_Error ("ResampleSfx: sound quality too high for resampling (%uHz, %u channel(s))",
+               {
+                       Con_Printf ("ResampleSfx: sound quality too high for resampling (%uHz, %u channel(s))",
                                           in_format->speed, in_format->channels);
+                       return 0;
+               }
 
                // We work 1 sec at a time to make sure we don't accumulate any
                // significant error when adding "fracstep" over several seconds, and
@@ -167,7 +170,7 @@ qboolean S_LoadSound (sfx_t *s, qboolean complain)
        if (s->fetcher != NULL)
        {
                if (s->format.speed != shm->format.speed)
-                       Sys_Error ("S_LoadSound: sound %s hasn't been resampled (%uHz instead of %uHz)", s->name);
+                       Con_Printf ("S_LoadSound: sound %s hasn't been resampled (%uHz instead of %uHz)", s->name);
                return true;
        }
 

diff --git a/sys_linux.c b/sys_linux.c
index f3db25efac8a6dc642ec3f6ffb1b6246a351c4bd..4bdaf077dfd565b44cf18bcbb34198d2ed6f7ddc 100644 (file)
--- a/sys_linux.c
+++ b/sys_linux.c
@@ -96,7 +96,12 @@ double Sys_DoubleTime (void)
                LARGE_INTEGER PerformanceCount;
 
                if (!QueryPerformanceFrequency (&PerformanceFreq))
-                       Sys_Error ("No hardware timer available");
+               {
+                       Con_Printf ("No hardware timer available");
+                       // fall back to timeGetTime
+                       Cvar_SetValueQuick(&sys_usetimegettime, true);
+                       return Sys_DoubleTime();
+               }
                QueryPerformanceCounter (&PerformanceCount);
 
                #ifdef __BORLANDC__

diff --git a/sys_win.c b/sys_win.c
index 90545065c24c41580170089e0123b64ad659e03d..71aae138c65c3e6f9c7aa8f8247270d21217f7f6 100644 (file)
--- a/sys_win.c
+++ b/sys_win.c
@@ -157,7 +157,12 @@ double Sys_DoubleTime (void)
                LARGE_INTEGER PerformanceCount;
 
                if (!QueryPerformanceFrequency (&PerformanceFreq))
-                       Sys_Error ("No hardware timer available");
+               {
+                       Con_Printf ("No hardware timer available");
+                       // fall back to timeGetTime
+                       Cvar_SetValueQuick(&sys_usetimegettime, true);
+                       return Sys_DoubleTime();
+               }
                QueryPerformanceCounter (&PerformanceCount);
 
                #ifdef __BORLANDC__

diff --git a/vid_glx.c b/vid_glx.c
index 5035a182c07b6dc2c9970591377946ef2a0e61dc..33d32d67d20b1743fdf2ace6ef31298efffa8b3d 100644 (file)
--- a/vid_glx.c
+++ b/vid_glx.c
@@ -830,15 +830,24 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
 
        ctx = qglXCreateContext(vidx11_display, visinfo, NULL, True);
        if (!ctx)
-               Sys_Error ("glXCreateContext failed\n");
+       {
+               Con_Printf ("glXCreateContext failed\n");
+               return false;
+       }
 
        if (!qglXMakeCurrent(vidx11_display, win, ctx))
-               Sys_Error ("glXMakeCurrent failed\n");
+       {
+               Con_Printf ("glXMakeCurrent failed\n");
+               return false;
+       }
 
        XSync(vidx11_display, False);
 
        if ((qglGetString = GL_GetProcAddress("glGetString")) == NULL)
-               Sys_Error("glGetString not found in %s", gl_driver);
+       {
+               Con_Printf ("glGetString not found in %s", gl_driver);
+               return false;
+       }
 
        gl_renderer = qglGetString(GL_RENDERER);
        gl_vendor = qglGetString(GL_VENDOR);

diff --git a/vid_wgl.c b/vid_wgl.c
index e014659c7080e0a1f28a0a20b7cdba43f5358a9f..0adee1c6c485435294a29aa1f71e51fd0923d8de 100644 (file)
--- a/vid_wgl.c
+++ b/vid_wgl.c
@@ -695,7 +695,7 @@ void VID_Init(void)
        wc.lpszClassName = "DarkPlacesWindowClass";
 
        if (!RegisterClass (&wc))
-               Sys_Error("Couldn't register window class\n");
+               Con_Printf ("Couldn't register window class\n");
 
        IN_Init();
 }