stricmp -> Q_stricmp

CODE-mp/client/FxScheduler.cpp

@@ -659,58 +659,58 @@ int CFxScheduler::ParseEffect( const char *file, CGPGroup *base )
 		grpName = primitiveGroup->GetName();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( grpName, "particle" ))
+		if ( !Q_stricmp( grpName, "particle" ))
 		{
 			type = Particle;
 		}
-		else if ( !stricmp( grpName, "line" ))
+		else if ( !Q_stricmp( grpName, "line" ))
 		{
 			type = Line;
 		}
-		else if ( !stricmp( grpName, "tail" ))
+		else if ( !Q_stricmp( grpName, "tail" ))
 		{
 			type = Tail;
 		}
-		else if ( !stricmp( grpName, "sound" ))
+		else if ( !Q_stricmp( grpName, "sound" ))
 		{
 			type = Sound;
 		}
-		else if ( !stricmp( grpName, "cylinder" ))
+		else if ( !Q_stricmp( grpName, "cylinder" ))
 		{
 			type = Cylinder;
 		}
-		else if ( !stricmp( grpName, "electricity" ))
+		else if ( !Q_stricmp( grpName, "electricity" ))
 		{
 			type = Electricity;
 		}
-		else if ( !stricmp( grpName, "emitter" ))
+		else if ( !Q_stricmp( grpName, "emitter" ))
 		{
 			type = Emitter;
 		}
-		else if ( !stricmp( grpName, "decal" ))
+		else if ( !Q_stricmp( grpName, "decal" ))
 		{
 			type = Decal;
 		}
-		else if ( !stricmp( grpName, "orientedparticle" ))
+		else if ( !Q_stricmp( grpName, "orientedparticle" ))
 		{
 			type = OrientedParticle;
 		}
-		else if ( !stricmp( grpName, "fxrunner" ))
+		else if ( !Q_stricmp( grpName, "fxrunner" ))
 		{
 			type = FxRunner;
 		}
-		else if ( !stricmp( grpName, "light" ))
+		else if ( !Q_stricmp( grpName, "light" ))
 		{
 			type = Light;
 		}
-		else if ( !stricmp( grpName, "cameraShake" ))
+		else if ( !Q_stricmp( grpName, "cameraShake" ))
 		{
 			type = CameraShake;
 		}
 /*
 		// NOTE:  Pat requested that flashes be disabled in MP.  Since fx files are shared with SP, this is the easiest way to accomplish that....
 		//	 code will fall through and become type NONE....and therefore not parsed and added to the effect definition.
-		else if ( !stricmp( grpName, "flash" ))
+		else if ( !Q_stricmp( grpName, "flash" ))
 		{
 			type = ScreenFlash;
 		}
@@ -887,7 +887,7 @@ CPrimitiveTemplate *CFxScheduler::GetPrimitiveCopy( SEffectTemplate *effectCopy,
 
 	for ( int i = 0; i < effectCopy->mPrimitiveCount; i++ )
 	{
-		if ( !stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
+		if ( !Q_stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
 		{
 			// we found a match, so return it
 			return effectCopy->mPrimitives[i];

CODE-mp/client/FxScheduler.h

@@ -385,7 +385,7 @@ struct SEffectTemplate
 
 	bool operator == (const char * name) const 
 	{
-		return !stricmp( mEffectName, name );
+		return !Q_stricmp( mEffectName, name );
 	}
 	void operator=(const SEffectTemplate &that);
 };

CODE-mp/client/FxTemplate.cpp

@@ -273,23 +273,23 @@ bool CPrimitiveTemplate::ParseGroupFlags( const char *val, int *flags )
 			return true;
 		}
 
-		if ( !stricmp( flag[i], "linear" ))
+		if ( !Q_stricmp( flag[i], "linear" ))
 		{
 			*flags |= FX_LINEAR;
 		}
-		else if ( !stricmp( flag[i], "nonlinear" ))
+		else if ( !Q_stricmp( flag[i], "nonlinear" ))
 		{
 			*flags |= FX_NONLINEAR;
 		}
-		else if ( !stricmp( flag[i], "wave" ))
+		else if ( !Q_stricmp( flag[i], "wave" ))
 		{
 			*flags |= FX_WAVE;
 		}
-		else if ( !stricmp( flag[i], "random" ))
+		else if ( !Q_stricmp( flag[i], "random" ))
 		{
 			*flags |= FX_RAND;
 		}
-		else if ( !stricmp( flag[i], "clamp" ))
+		else if ( !Q_stricmp( flag[i], "clamp" ))
 		{
 			*flags |= FX_CLAMP;
 		}
@@ -716,51 +716,51 @@ bool CPrimitiveTemplate::ParseFlags( const char *val )
 			return true;
 		}
 
-		if ( !stricmp( flag[i], "useModel" ))
+		if ( !Q_stricmp( flag[i], "useModel" ))
 		{
 			mFlags |= FX_ATTACHED_MODEL;
 		}
-		else if ( !stricmp( flag[i], "useBBox" ))
+		else if ( !Q_stricmp( flag[i], "useBBox" ))
 		{
 			mFlags |= FX_USE_BBOX;
 		}
-		else if ( !stricmp( flag[i], "usePhysics" ))
+		else if ( !Q_stricmp( flag[i], "usePhysics" ))
 		{
 			mFlags |= FX_APPLY_PHYSICS;
 		}
-		else if ( !stricmp( flag[i], "expensivePhysics" ))
+		else if ( !Q_stricmp( flag[i], "expensivePhysics" ))
 		{
 			mFlags |= FX_EXPENSIVE_PHYSICS;
 		}
-		else if ( !stricmp( flag[i], "impactKills" ))
+		else if ( !Q_stricmp( flag[i], "impactKills" ))
 		{
 			mFlags |= FX_KILL_ON_IMPACT;
 		}
-		else if ( !stricmp( flag[i], "impactFx" ))
+		else if ( !Q_stricmp( flag[i], "impactFx" ))
 		{
 			mFlags |= FX_IMPACT_RUNS_FX;
 		}
-		else if ( !stricmp( flag[i], "deathFx" ))
+		else if ( !Q_stricmp( flag[i], "deathFx" ))
 		{
 			mFlags |= FX_DEATH_RUNS_FX;
 		}
-		else if ( !stricmp( flag[i], "useAlpha" ))
+		else if ( !Q_stricmp( flag[i], "useAlpha" ))
 		{
 			mFlags |= FX_USE_ALPHA;
 		}
-		else if ( !stricmp( flag[i], "emitFx" ))
+		else if ( !Q_stricmp( flag[i], "emitFx" ))
 		{
 			mFlags |= FX_EMIT_FX;
 		}
-		else if ( !stricmp( flag[i], "depthHack" ))
+		else if ( !Q_stricmp( flag[i], "depthHack" ))
 		{
 			mFlags |= FX_DEPTH_HACK;
 		}
-		else if ( !stricmp( flag[i], "relative" ))
+		else if ( !Q_stricmp( flag[i], "relative" ))
 		{
 			mFlags |= FX_RELATIVE;
 		}
-		else if ( !stricmp( flag[i], "setShaderTime" ))
+		else if ( !Q_stricmp( flag[i], "setShaderTime" ))
 		{
 			mFlags |= FX_SET_SHADER_TIME;
 		}
@@ -799,59 +799,59 @@ bool CPrimitiveTemplate::ParseSpawnFlags( const char *val )
 			return true;
 		}
 
-		if ( !stricmp( flag[i], "org2fromTrace" ))
+		if ( !Q_stricmp( flag[i], "org2fromTrace" ))
 		{
 			mSpawnFlags |= FX_ORG2_FROM_TRACE;
 		}
-		else if ( !stricmp( flag[i], "traceImpactFx" ))
+		else if ( !Q_stricmp( flag[i], "traceImpactFx" ))
 		{
 			mSpawnFlags |= FX_TRACE_IMPACT_FX;
 		}
-		else if ( !stricmp( flag[i], "org2isOffset" ))
+		else if ( !Q_stricmp( flag[i], "org2isOffset" ))
 		{
 			mSpawnFlags |= FX_ORG2_IS_OFFSET;
 		}
-		else if ( !stricmp( flag[i], "cheapOrgCalc" ))
+		else if ( !Q_stricmp( flag[i], "cheapOrgCalc" ))
 		{
 			mSpawnFlags |= FX_CHEAP_ORG_CALC;
 		}
-		else if ( !stricmp( flag[i], "cheapOrg2Calc" ))
+		else if ( !Q_stricmp( flag[i], "cheapOrg2Calc" ))
 		{
 			mSpawnFlags |= FX_CHEAP_ORG2_CALC;
 		}
-		else if ( !stricmp( flag[i], "absoluteVel" ))
+		else if ( !Q_stricmp( flag[i], "absoluteVel" ))
 		{
 			mSpawnFlags |= FX_VEL_IS_ABSOLUTE;
 		}
-		else if ( !stricmp( flag[i], "absoluteAccel" ))
+		else if ( !Q_stricmp( flag[i], "absoluteAccel" ))
 		{
 			mSpawnFlags |= FX_ACCEL_IS_ABSOLUTE;
 		}
-		else if ( !stricmp( flag[i], "orgOnSphere" ))
+		else if ( !Q_stricmp( flag[i], "orgOnSphere" ))
 		{
 			mSpawnFlags |= FX_ORG_ON_SPHERE;
 		}
-		else if ( !stricmp( flag[i], "orgOnCylinder" ))
+		else if ( !Q_stricmp( flag[i], "orgOnCylinder" ))
 		{
 			mSpawnFlags |= FX_ORG_ON_CYLINDER;
 		}
-		else if ( !stricmp( flag[i], "axisFromSphere" ))
+		else if ( !Q_stricmp( flag[i], "axisFromSphere" ))
 		{
 			mSpawnFlags |= FX_AXIS_FROM_SPHERE;
 		}
-		else if ( !stricmp( flag[i], "randrotaroundfwd" ))
+		else if ( !Q_stricmp( flag[i], "randrotaroundfwd" ))
 		{
 			mSpawnFlags |= FX_RAND_ROT_AROUND_FWD;
 		}
-		else if ( !stricmp( flag[i], "evenDistribution" ))
+		else if ( !Q_stricmp( flag[i], "evenDistribution" ))
 		{
 			mSpawnFlags |= FX_EVEN_DISTRIBUTION;
 		}
-		else if ( !stricmp( flag[i], "rgbComponentInterpolation" ))
+		else if ( !Q_stricmp( flag[i], "rgbComponentInterpolation" ))
 		{
 			mSpawnFlags |= FX_RGB_COMPONENT_INTERP;
 		}
-		else if ( !stricmp( flag[i], "affectedByWind" ))
+		else if ( !Q_stricmp( flag[i], "affectedByWind" ))
 		{
 			mSpawnFlags |= FX_AFFECTED_BY_WIND;
 		}
@@ -1899,19 +1899,19 @@ bool CPrimitiveTemplate::ParseRGB( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "start" ))
+		if ( !Q_stricmp( key, "start" ))
 		{
 			ParseRGBStart( val );
 		}
-		else if ( !stricmp( key, "end" ))
+		else if ( !Q_stricmp( key, "end" ))
 		{
 			ParseRGBEnd( val );
 		}
-		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
 		{
 			ParseRGBParm( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{
 			ParseRGBFlags( val );
 		}
@@ -1953,19 +1953,19 @@ bool CPrimitiveTemplate::ParseAlpha( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "start" ))
+		if ( !Q_stricmp( key, "start" ))
 		{
 			ParseAlphaStart( val );
 		}
-		else if ( !stricmp( key, "end" ))
+		else if ( !Q_stricmp( key, "end" ))
 		{
 			ParseAlphaEnd( val );
 		}
-		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
 		{
 			ParseAlphaParm( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{
 			ParseAlphaFlags( val );
 		}
@@ -2007,19 +2007,19 @@ bool CPrimitiveTemplate::ParseSize( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "start" ))
+		if ( !Q_stricmp( key, "start" ))
 		{
 			ParseSizeStart( val );
 		}
-		else if ( !stricmp( key, "end" ))
+		else if ( !Q_stricmp( key, "end" ))
 		{
 			ParseSizeEnd( val );
 		}
-		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
 		{
 			ParseSizeParm( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{
 			ParseSizeFlags( val );
 		}
@@ -2061,19 +2061,19 @@ bool CPrimitiveTemplate::ParseSize2( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "start" ))
+		if ( !Q_stricmp( key, "start" ))
 		{
 			ParseSize2Start( val );
 		}
-		else if ( !stricmp( key, "end" ))
+		else if ( !Q_stricmp( key, "end" ))
 		{
 			ParseSize2End( val );
 		}
-		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
 		{
 			ParseSize2Parm( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{
 			ParseSize2Flags( val );
 		}
@@ -2115,19 +2115,19 @@ bool CPrimitiveTemplate::ParseLength( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "start" ))
+		if ( !Q_stricmp( key, "start" ))
 		{
 			ParseLengthStart( val );
 		}
-		else if ( !stricmp( key, "end" ))
+		else if ( !Q_stricmp( key, "end" ))
 		{
 			ParseLengthEnd( val );
 		}
-		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
 		{
 			ParseLengthParm( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{
 			ParseLengthFlags( val );
 		}
@@ -2163,112 +2163,112 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
 		val = pairs->GetTopValue();
 
 		// Huge stricmp lists suxor
-		if ( !stricmp( key, "count" ))
+		if ( !Q_stricmp( key, "count" ))
 		{
 			ParseCount( val );
 		}
-		else if ( !stricmp( key, "shaders" ) || !stricmp( key, "shader" ))
+		else if ( !Q_stricmp( key, "shaders" ) || !Q_stricmp( key, "shader" ))
 		{
 			ParseShaders( pairs );
 		}
-		else if ( !stricmp( key, "models" ) || !stricmp( key, "model" ))
+		else if ( !Q_stricmp( key, "models" ) || !Q_stricmp( key, "model" ))
 		{
 			ParseModels( pairs );
 		}
-		else if ( !stricmp( key, "sounds" ) || !stricmp( key, "sound" ))
+		else if ( !Q_stricmp( key, "sounds" ) || !Q_stricmp( key, "sound" ))
 		{
 			ParseSounds( pairs );
 		}
-		else if ( !stricmp( key, "impactfx" ))
+		else if ( !Q_stricmp( key, "impactfx" ))
 		{
 			ParseImpactFxStrings( pairs );
 		}
-		else if ( !stricmp( key, "deathfx" ))
+		else if ( !Q_stricmp( key, "deathfx" ))
 		{
 			ParseDeathFxStrings( pairs );
 		}
-		else if ( !stricmp( key, "emitfx" ))
+		else if ( !Q_stricmp( key, "emitfx" ))
 		{
 			ParseEmitterFxStrings( pairs );
 		}
-		else if ( !stricmp( key, "playfx" ))
+		else if ( !Q_stricmp( key, "playfx" ))
 		{
 			ParsePlayFxStrings( pairs );
 		}
-		else if ( !stricmp( key, "life" ))
+		else if ( !Q_stricmp( key, "life" ))
 		{
 			ParseLife( val );
 		}
-		else if ( !stricmp( key, "cullrange" ))
+		else if ( !Q_stricmp( key, "cullrange" ))
 		{
 			mCullRange = atoi( val );
 			mCullRange *= mCullRange; // Square
 		}
-		else if ( !stricmp( key, "delay" ))
+		else if ( !Q_stricmp( key, "delay" ))
 		{
 			ParseDelay( val );
 		}
-		else if ( !stricmp( key, "bounce" ) || !stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
+		else if ( !Q_stricmp( key, "bounce" ) || !Q_stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
 		{
 			ParseElasticity( val );
 		}
-		else if ( !stricmp( key, "min" ))
+		else if ( !Q_stricmp( key, "min" ))
 		{
 			ParseMin( val );
 		}
-		else if ( !stricmp( key, "max" ))
+		else if ( !Q_stricmp( key, "max" ))
 		{
 			ParseMax( val );
 		}
-		else if ( !stricmp( key, "angle" ) || !stricmp( key, "angles" ))
+		else if ( !Q_stricmp( key, "angle" ) || !Q_stricmp( key, "angles" ))
 		{
 			ParseAngle( val );
 		}
-		else if ( !stricmp( key, "angleDelta" ))
+		else if ( !Q_stricmp( key, "angleDelta" ))
 		{
 			ParseAngleDelta( val );
 		}
-		else if ( !stricmp( key, "velocity" ) || !stricmp( key, "vel" ))
+		else if ( !Q_stricmp( key, "velocity" ) || !Q_stricmp( key, "vel" ))
 		{
 			ParseVelocity( val );
 		}
-		else if ( !stricmp( key, "acceleration" ) || !stricmp( key, "accel" ))
+		else if ( !Q_stricmp( key, "acceleration" ) || !Q_stricmp( key, "accel" ))
 		{
 			ParseAcceleration( val );
 		}
-		else if ( !stricmp( key, "gravity" ))
+		else if ( !Q_stricmp( key, "gravity" ))
 		{
 			ParseGravity( val );
 		}
-		else if ( !stricmp( key, "density" ))
+		else if ( !Q_stricmp( key, "density" ))
 		{
 			ParseDensity( val );
 		}
-		else if ( !stricmp( key, "variance" ))
+		else if ( !Q_stricmp( key, "variance" ))
 		{
 			ParseVariance( val );
 		}
-		else if ( !stricmp( key, "origin" ))
+		else if ( !Q_stricmp( key, "origin" ))
 		{
 			ParseOrigin1( val );
 		}
-		else if ( !stricmp( key, "origin2" ))
+		else if ( !Q_stricmp( key, "origin2" ))
 		{
 			ParseOrigin2( val );
 		}
-		else if ( !stricmp( key, "radius" ))
+		else if ( !Q_stricmp( key, "radius" ))
 		{
 			ParseRadius( val );
 		}
-		else if ( !stricmp( key, "height" ))
+		else if ( !Q_stricmp( key, "height" ))
 		{
 			ParseHeight( val );
 		}
-		else if ( !stricmp( key, "wind" ))
+		else if ( !Q_stricmp( key, "wind" ))
 		{
 			ParseWindModifier( val );
 		}
-		else if ( !stricmp( key, "rotation" ))
+		else if ( !Q_stricmp( key, "rotation" ))
 		{
 			ParseRotation( val );
 		}
@@ -2276,15 +2276,15 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
 		{
 			ParseRotationDelta( val );
 		}
-		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
 		{ // these need to get passed on to the primitive
 			ParseFlags( val );
 		}
-		else if ( !stricmp( key, "spawnFlags" ) || !stricmp( key, "spawnFlag" ))
+		else if ( !Q_stricmp( key, "spawnFlags" ) || !Q_stricmp( key, "spawnFlag" ))
 		{ // these are used to spawn things in cool ways, but don't ever get passed on to prims.
 			ParseSpawnFlags( val );
 		}
-		else if ( !stricmp( key, "name" ))
+		else if ( !Q_stricmp( key, "name" ))
 		{
 			if ( val )
 			{
@@ -2307,23 +2307,23 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
 	{
 		key = subGrp->GetName();
 
-		if ( !stricmp( key, "rgb" ))
+		if ( !Q_stricmp( key, "rgb" ))
 		{
 			ParseRGB( subGrp );
 		}
-		else if ( !stricmp( key, "alpha" ))
+		else if ( !Q_stricmp( key, "alpha" ))
 		{
 			ParseAlpha( subGrp );
 		}
-		else if ( !stricmp( key, "size" ) || !stricmp( key, "width" ))
+		else if ( !Q_stricmp( key, "size" ) || !Q_stricmp( key, "width" ))
 		{
 			ParseSize( subGrp );
 		}
-		else if ( !stricmp( key, "size2" ) || !stricmp( key, "width2" ))
+		else if ( !Q_stricmp( key, "size2" ) || !Q_stricmp( key, "width2" ))
 		{
 			ParseSize2( subGrp );
 		}
-		else if ( !stricmp( key, "length" ) || !stricmp( key, "height" ))
+		else if ( !Q_stricmp( key, "length" ) || !Q_stricmp( key, "height" ))
 		{
 			ParseLength( subGrp );
 		}

CODE-mp/client/cl_keys.cpp

@@ -1013,7 +1013,7 @@ int Key_StringToKeynum( char *str ) {
 	// scan for a text match
 	for ( i = 0 ; i < MAX_KEYS ; i++ ) 
 	{
-		if ( keynames[i].name && !stricmp( str, keynames[i].name ) )
+		if ( keynames[i].name && !Q_stricmp( str, keynames[i].name ) )
 		{
 			return keynames[i].keynum;
 		}

CODE-mp/client/snd_mem.cpp

@@ -281,15 +281,15 @@ static qboolean S_LoadSound_FileLoadAndNameAdjuster(char *psFilename, byte **pDa
 		// account for foreign voices...
 		//		
 		extern cvar_t* s_language;
-		if (s_language && stricmp("DEUTSCH",s_language->string)==0)
+		if (s_language && Q_stricmp("DEUTSCH",s_language->string)==0)
 		{				
 			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
 		}
-		else if (s_language && stricmp("FRANCAIS",s_language->string)==0)
+		else if (s_language && Q_stricmp("FRANCAIS",s_language->string)==0)
 		{				
 			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
 		}
-		else if (s_language && stricmp("ESPANOL",s_language->string)==0)
+		else if (s_language && Q_stricmp("ESPANOL",s_language->string)==0)
 		{				
 			strncpy(psVoice,"chr_e",5);	// same number of letters as "chars"
 		}

CODE-mp/game/g_items.c

@@ -1839,7 +1839,7 @@ void FinishSpawningItem( gentity_t *ent ) {
 
 	// create a Ghoul2 model if the world model is a glm
 /*	item = &bg_itemlist[ ent->s.modelindex ];
-	if (!stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
+	if (!Q_stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
 	{
 		trap_G2API_InitGhoul2Model(&ent->s, item->world_model[0], G_ModelIndex(item->world_model[0] ), 0, 0, 0, 0);
 		ent->s.radius = 60;

CODE-mp/game/q_shared.h

@@ -124,7 +124,6 @@ static ID_INLINE float BigFloat(const float *l) { FloatSwap(l); }
 #define MAC_STATIC
 #define __cdecl
 #define __declspec(x)
-#define stricmp strcasecmp
 #define ID_INLINE inline 
 
 #ifdef __ppc__
@@ -200,9 +199,6 @@ static inline float LittleFloat (const float l) { return FloatSwap(&l); }
 // just waste space and make big arrays static...
 #ifdef __linux__
 
-// bk001205 - from Makefile
-#define stricmp strcasecmp
-
 #define	MAC_STATIC // bk: FIXME
 #define ID_INLINE inline 
 
@@ -248,9 +244,6 @@ inline static float LittleFloat (const float *l) { return FloatSwap(l); }
 // just waste space and make big arrays static...
 #ifdef __OpenBSD__
 
-// bk001205 - from Makefile
-#define stricmp strcasecmp
-
 #define	MAC_STATIC // bk: FIXME
 #define ID_INLINE inline 
 
@@ -295,8 +288,6 @@ inline static float LittleFloat (const float *l) { return FloatSwap(l); }
 //======================= FreeBSD DEFINES =====================
 #ifdef __FreeBSD__ // rb010123
 
-#define stricmp strcasecmp
-
 #define MAC_STATIC
 #define ID_INLINE inline 
 

CODE-mp/ghoul2/G2_bolts.cpp

@@ -179,7 +179,7 @@ int G2_Add_Bolt(const char *fileName, boltInfo_v &bltlist, surfaceInfo_v &slist,
  	{
  		skel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
  		// if name is the same, we found it
- 		if (!stricmp(skel->name, boneName))
+ 		if (!Q_stricmp(skel->name, boneName))
 		{
 			break;
 		}

CODE-mp/ghoul2/G2_bones.cpp

@@ -47,7 +47,7 @@ int G2_Find_Bone(const model_t *mod, boneInfo_v &blist, const char *boneName)
 		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
 
 		// if name is the same, we found it
-		if (!stricmp(skel->name, boneName))
+		if (!Q_stricmp(skel->name, boneName))
 		{
 			return i;
 		}
@@ -72,7 +72,7 @@ int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
  	{
  		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
  		// if name is the same, we found it
- 		if (!stricmp(skel->name, boneName))
+ 		if (!Q_stricmp(skel->name, boneName))
 		{
 			break;
 		}
@@ -94,7 +94,7 @@ int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
 		{
 			skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
 			// if name is the same, we found it
-			if (!stricmp(skel->name, boneName))
+			if (!Q_stricmp(skel->name, boneName))
 			{
 				return i;
 			}

CODE-mp/ghoul2/G2_misc.cpp

@@ -1650,7 +1650,7 @@ int G2_FindConfigStringSpace(char *name, int start, int max)
 		{
 			break;
 		}
-		if ( !stricmp( s, name ) ) 
+		if ( !Q_stricmp( s, name ) ) 
 		{
 			return i;
 		}

CODE-mp/ghoul2/G2_surfaces.cpp

@@ -72,7 +72,7 @@ int G2_IsSurfaceLegal(void *mod, const char *surfaceName, int *flags)
 
 	for ( int i = 0 ; i < mod_m->mdxm->numSurfaces ; i++) 
 	{
-	 	if (!stricmp(surfaceName, surf->name))
+	 	if (!Q_stricmp(surfaceName, surf->name))
 	 	{
 			*flags = surf->flags;
 			return i;
@@ -126,7 +126,7 @@ mdxmSurface_t *G2_FindSurface(const char *fileName, surfaceInfo_v &slist, const
 			surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
 
   			// are these the droids we're looking for?
-			if (!stricmp (surfInfo->name, surfaceName))
+			if (!Q_stricmp (surfInfo->name, surfaceName))
 			{
 				// yup
 				if (surfIndex)
@@ -218,7 +218,7 @@ int G2_IsSurfaceOff (const char *fileName, surfaceInfo_v &slist, const char *sur
 
 	for ( int i = 0 ; i < mod->mdxm->numSurfaces ; i++) 
 	{
-	 	if (!stricmp(surfaceName, surface->name))
+	 	if (!Q_stricmp(surfaceName, surface->name))
 	 	{
 			return surface->flags;
 		}

CODE-mp/qcommon/GenericParser2.cpp

@@ -512,7 +512,7 @@ CGPGroup *CGPGroup::FindSubGroup(const char *name)
 	group = mSubGroups;
 	while(group)
 	{
-		if(!stricmp(name, group->GetName()))
+		if(!Q_stricmp(name, group->GetName()))
 		{
 			return(group);
 		}

CODE-mp/renderer/tr_model.cpp

@@ -398,7 +398,7 @@ static void RE_RegisterModels_DumpNonPure(void)
 
 		if (iInPak == -1 || iCheckSum != CachedModel.iPAKFileCheckSum)
 		{
-			if (stricmp(sDEFAULT_GLA_NAME ".gla" , psModelName))	// don't dump "*default.gla", that's program internal anyway
+			if (Q_stricmp(sDEFAULT_GLA_NAME ".gla" , psModelName))	// don't dump "*default.gla", that's program internal anyway
 			{
 				// either this is not from a PAK, or it's from a non-pure one, so ditch it...
 				//					

CODE-mp/renderer/tr_shader.cpp

@@ -71,7 +71,7 @@ int R_FindHitMat(const char *fname)
 	// simple linear search, this should only be called during precache anyway
 	for (i=1; i<hitMatCount; i++)
 	{
-		if (!stricmp(hitMatReg[i].name, fname))
+		if (!Q_stricmp(hitMatReg[i].name, fname))
 		{
 			return i;
 		}

CODE-mp/unix/linux_glimp.cpp

@@ -1305,7 +1305,7 @@ void GLimp_Init( void )
 void GLimp_EndFrame (void)
 {
 	// don't flip if drawing to front buffer
-	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
 	{
 		qglXSwapBuffers(dpy, win);
 	}

CODE-mp/win32/win_glimp.cpp

@@ -1324,7 +1324,7 @@ void GLimp_EndFrame (void)
 
 
 	// don't flip if drawing to front buffer
-	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
 	{
 		SwapBuffers( glw_state.hDC );
 	}