newlines fixed

git-svn-id: svn://svn.icculus.org/quake3/trunk@6 edf5b092-35ff-0310-97b2-ce42778d08ea

1 files changed, 3228 insertions, 3228 deletions

diff --git a/code/botlib/l_precomp.c b/code/botlib/l_precomp.c
index 4fa708b..ae82981 100755
--- a/code/botlib/l_precomp.c
+++ b/code/botlib/l_precomp.c
@@ -1,3228 +1,3228 @@
-/*

-===========================================================================

-Copyright (C) 1999-2005 Id Software, Inc.

-

-This file is part of Quake III Arena source code.

-

-Quake III Arena source code is free software; you can redistribute it

-and/or modify it under the terms of the GNU General Public License as

-published by the Free Software Foundation; either version 2 of the License,

-or (at your option) any later version.

-

-Quake III Arena source code is distributed in the hope that it will be

-useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with Foobar; if not, write to the Free Software

-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

-===========================================================================

-*/

-//

-

-/*****************************************************************************

- * name:		l_precomp.c

- *

- * desc:		pre compiler

- *

- * $Archive: /MissionPack/code/botlib/l_precomp.c $

- *

- *****************************************************************************/

-

-//Notes:			fix: PC_StringizeTokens

-

-//#define SCREWUP

-//#define BOTLIB

-//#define QUAKE

-//#define QUAKEC

-//#define MEQCC

-

-#ifdef SCREWUP

-#include <stdio.h>

-#include <stdlib.h>

-#include <limits.h>

-#include <string.h>

-#include <stdarg.h>

-#include <time.h>

-#include "l_memory.h"

-#include "l_script.h"

-#include "l_precomp.h"

-

-typedef enum {qfalse, qtrue}	qboolean;

-#endif //SCREWUP

-

-#ifdef BOTLIB

-#include "../game/q_shared.h"

-#include "../game/botlib.h"

-#include "be_interface.h"

-#include "l_memory.h"

-#include "l_script.h"

-#include "l_precomp.h"

-#include "l_log.h"

-#endif //BOTLIB

-

-#ifdef MEQCC

-#include "qcc.h"

-#include "time.h"   //time & ctime

-#include "math.h"   //fabs

-#include "l_memory.h"

-#include "l_script.h"

-#include "l_precomp.h"

-#include "l_log.h"

-

-#define qtrue	true

-#define qfalse	false

-#endif //MEQCC

-

-#ifdef BSPC

-//include files for usage in the BSP Converter

-#include "../bspc/qbsp.h"

-#include "../bspc/l_log.h"

-#include "../bspc/l_mem.h"

-#include "l_precomp.h"

-

-#define qtrue	true

-#define qfalse	false

-#define Q_stricmp	stricmp

-

-#endif //BSPC

-

-#if defined(QUAKE) && !defined(BSPC)

-#include "l_utils.h"

-#endif //QUAKE

-

-//#define DEBUG_EVAL

-

-#define MAX_DEFINEPARMS			128

-

-#define DEFINEHASHING			1

-

-//directive name with parse function

-typedef struct directive_s

-{

-	char *name;

-	int (*func)(source_t *source);

-} directive_t;

-

-#define DEFINEHASHSIZE		1024

-

-#define TOKEN_HEAP_SIZE		4096

-

-int numtokens;

-/*

-int tokenheapinitialized;				//true when the token heap is initialized

-token_t token_heap[TOKEN_HEAP_SIZE];	//heap with tokens

-token_t *freetokens;					//free tokens from the heap

-*/

-

-//list with global defines added to every source loaded

-define_t *globaldefines;

-

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void QDECL SourceError(source_t *source, char *str, ...)

-{

-	char text[1024];

-	va_list ap;

-

-	va_start(ap, str);

-	vsprintf(text, str, ap);

-	va_end(ap);

-#ifdef BOTLIB

-	botimport.Print(PRT_ERROR, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif	//BOTLIB

-#ifdef MEQCC

-	printf("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif //MEQCC

-#ifdef BSPC

-	Log_Print("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif //BSPC

-} //end of the function SourceError

-//===========================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//===========================================================================

-void QDECL SourceWarning(source_t *source, char *str, ...)

-{

-	char text[1024];

-	va_list ap;

-

-	va_start(ap, str);

-	vsprintf(text, str, ap);

-	va_end(ap);

-#ifdef BOTLIB

-	botimport.Print(PRT_WARNING, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif //BOTLIB

-#ifdef MEQCC

-	printf("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif //MEQCC

-#ifdef BSPC

-	Log_Print("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);

-#endif //BSPC

-} //end of the function ScriptWarning

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_PushIndent(source_t *source, int type, int skip)

-{

-	indent_t *indent;

-

-	indent = (indent_t *) GetMemory(sizeof(indent_t));

-	indent->type = type;

-	indent->script = source->scriptstack;

-	indent->skip = (skip != 0);

-	source->skip += indent->skip;

-	indent->next = source->indentstack;

-	source->indentstack = indent;

-} //end of the function PC_PushIndent

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_PopIndent(source_t *source, int *type, int *skip)

-{

-	indent_t *indent;

-

-	*type = 0;

-	*skip = 0;

-

-	indent = source->indentstack;

-	if (!indent) return;

-

-	//must be an indent from the current script

-	if (source->indentstack->script != source->scriptstack) return;

-

-	*type = indent->type;

-	*skip = indent->skip;

-	source->indentstack = source->indentstack->next;

-	source->skip -= indent->skip;

-	FreeMemory(indent);

-} //end of the function PC_PopIndent

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_PushScript(source_t *source, script_t *script)

-{

-	script_t *s;

-

-	for (s = source->scriptstack; s; s = s->next)

-	{

-		if (!Q_stricmp(s->filename, script->filename))

-		{

-			SourceError(source, "%s recursively included", script->filename);

-			return;

-		} //end if

-	} //end for

-	//push the script on the script stack

-	script->next = source->scriptstack;

-	source->scriptstack = script;

-} //end of the function PC_PushScript

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-void PC_InitTokenHeap(void)

-{

-	/*

-	int i;

-

-	if (tokenheapinitialized) return;

-	freetokens = NULL;

-	for (i = 0; i < TOKEN_HEAP_SIZE; i++)

-	{

-		token_heap[i].next = freetokens;

-		freetokens = &token_heap[i];

-	} //end for

-	tokenheapinitialized = qtrue;

-	*/

-} //end of the function PC_InitTokenHeap

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-token_t *PC_CopyToken(token_t *token)

-{

-	token_t *t;

-

-//	t = (token_t *) malloc(sizeof(token_t));

-	t = (token_t *) GetMemory(sizeof(token_t));

-//	t = freetokens;

-	if (!t)

-	{

-#ifdef BSPC

-		Error("out of token space\n");

-#else

-		Com_Error(ERR_FATAL, "out of token space\n");

-#endif

-		return NULL;

-	} //end if

-//	freetokens = freetokens->next;

-	Com_Memcpy(t, token, sizeof(token_t));

-	t->next = NULL;

-	numtokens++;

-	return t;

-} //end of the function PC_CopyToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_FreeToken(token_t *token)

-{

-	//free(token);

-	FreeMemory(token);

-//	token->next = freetokens;

-//	freetokens = token;

-	numtokens--;

-} //end of the function PC_FreeToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ReadSourceToken(source_t *source, token_t *token)

-{

-	token_t *t;

-	script_t *script;

-	int type, skip;

-

-	//if there's no token already available

-	while(!source->tokens)

-	{

-		//if there's a token to read from the script

-		if (PS_ReadToken(source->scriptstack, token)) return qtrue;

-		//if at the end of the script

-		if (EndOfScript(source->scriptstack))

-		{

-			//remove all indents of the script

-			while(source->indentstack &&

-					source->indentstack->script == source->scriptstack)

-			{

-				SourceWarning(source, "missing #endif");

-				PC_PopIndent(source, &type, &skip);

-			} //end if

-		} //end if

-		//if this was the initial script

-		if (!source->scriptstack->next) return qfalse;

-		//remove the script and return to the last one

-		script = source->scriptstack;

-		source->scriptstack = source->scriptstack->next;

-		FreeScript(script);

-	} //end while

-	//copy the already available token

-	Com_Memcpy(token, source->tokens, sizeof(token_t));

-	//free the read token

-	t = source->tokens;

-	source->tokens = source->tokens->next;

-	PC_FreeToken(t);

-	return qtrue;

-} //end of the function PC_ReadSourceToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_UnreadSourceToken(source_t *source, token_t *token)

-{

-	token_t *t;

-

-	t = PC_CopyToken(token);

-	t->next = source->tokens;

-	source->tokens = t;

-	return qtrue;

-} //end of the function PC_UnreadSourceToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ReadDefineParms(source_t *source, define_t *define, token_t **parms, int maxparms)

-{

-	token_t token, *t, *last;

-	int i, done, lastcomma, numparms, indent;

-

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "define %s missing parms", define->name);

-		return qfalse;

-	} //end if

-	//

-	if (define->numparms > maxparms)

-	{

-		SourceError(source, "define with more than %d parameters", maxparms);

-		return qfalse;

-	} //end if

-	//

-	for (i = 0; i < define->numparms; i++) parms[i] = NULL;

-	//if no leading "("

-	if (strcmp(token.string, "("))

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "define %s missing parms", define->name);

-		return qfalse;

-	} //end if

-	//read the define parameters

-	for (done = 0, numparms = 0, indent = 0; !done;)

-	{

-		if (numparms >= maxparms)

-		{

-			SourceError(source, "define %s with too many parms", define->name);

-			return qfalse;

-		} //end if

-		if (numparms >= define->numparms)

-		{

-			SourceWarning(source, "define %s has too many parms", define->name);

-			return qfalse;

-		} //end if

-		parms[numparms] = NULL;

-		lastcomma = 1;

-		last = NULL;

-		while(!done)

-		{

-			//

-			if (!PC_ReadSourceToken(source, &token))

-			{

-				SourceError(source, "define %s incomplete", define->name);

-				return qfalse;

-			} //end if

-			//

-			if (!strcmp(token.string, ","))

-			{

-				if (indent <= 0)

-				{

-					if (lastcomma) SourceWarning(source, "too many comma's");

-					lastcomma = 1;

-					break;

-				} //end if

-			} //end if

-			lastcomma = 0;

-			//

-			if (!strcmp(token.string, "("))

-			{

-				indent++;

-				continue;

-			} //end if

-			else if (!strcmp(token.string, ")"))

-			{

-				if (--indent <= 0)

-				{

-					if (!parms[define->numparms-1])

-					{

-						SourceWarning(source, "too few define parms");

-					} //end if

-					done = 1;

-					break;

-				} //end if

-			} //end if

-			//

-			if (numparms < define->numparms)

-			{

-				//

-				t = PC_CopyToken(&token);

-				t->next = NULL;

-				if (last) last->next = t;

-				else parms[numparms] = t;

-				last = t;

-			} //end if

-		} //end while

-		numparms++;

-	} //end for

-	return qtrue;

-} //end of the function PC_ReadDefineParms

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_StringizeTokens(token_t *tokens, token_t *token)

-{

-	token_t *t;

-

-	token->type = TT_STRING;

-	token->whitespace_p = NULL;

-	token->endwhitespace_p = NULL;

-	token->string[0] = '\0';

-	strcat(token->string, "\"");

-	for (t = tokens; t; t = t->next)

-	{

-		strncat(token->string, t->string, MAX_TOKEN - strlen(token->string));

-	} //end for

-	strncat(token->string, "\"", MAX_TOKEN - strlen(token->string));

-	return qtrue;

-} //end of the function PC_StringizeTokens

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_MergeTokens(token_t *t1, token_t *t2)

-{

-	//merging of a name with a name or number

-	if (t1->type == TT_NAME && (t2->type == TT_NAME || t2->type == TT_NUMBER))

-	{

-		strcat(t1->string, t2->string);

-		return qtrue;

-	} //end if

-	//merging of two strings

-	if (t1->type == TT_STRING && t2->type == TT_STRING)

-	{

-		//remove trailing double quote

-		t1->string[strlen(t1->string)-1] = '\0';

-		//concat without leading double quote

-		strcat(t1->string, &t2->string[1]);

-		return qtrue;

-	} //end if

-	//FIXME: merging of two number of the same sub type

-	return qfalse;

-} //end of the function PC_MergeTokens

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-/*

-void PC_PrintDefine(define_t *define)

-{

-	printf("define->name = %s\n", define->name);

-	printf("define->flags = %d\n", define->flags);

-	printf("define->builtin = %d\n", define->builtin);

-	printf("define->numparms = %d\n", define->numparms);

-//	token_t *parms;					//define parameters

-//	token_t *tokens;					//macro tokens (possibly containing parm tokens)

-//	struct define_s *next;			//next defined macro in a list

-} //end of the function PC_PrintDefine*/

-#if DEFINEHASHING

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_PrintDefineHashTable(define_t **definehash)

-{

-	int i;

-	define_t *d;

-

-	for (i = 0; i < DEFINEHASHSIZE; i++)

-	{

-		Log_Write("%4d:", i);

-		for (d = definehash[i]; d; d = d->hashnext)

-		{

-			Log_Write(" %s", d->name);

-		} //end for

-		Log_Write("\n");

-	} //end for

-} //end of the function PC_PrintDefineHashTable

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-//char primes[16] = {1, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 41, 43, 47};

-

-int PC_NameHash(char *name)

-{

-	int register hash, i;

-

-	hash = 0;

-	for (i = 0; name[i] != '\0'; i++)

-	{

-		hash += name[i] * (119 + i);

-		//hash += (name[i] << 7) + i;

-		//hash += (name[i] << (i&15));

-	} //end while

-	hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (DEFINEHASHSIZE-1);

-	return hash;

-} //end of the function PC_NameHash

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_AddDefineToHash(define_t *define, define_t **definehash)

-{

-	int hash;

-

-	hash = PC_NameHash(define->name);

-	define->hashnext = definehash[hash];

-	definehash[hash] = define;

-} //end of the function PC_AddDefineToHash

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-define_t *PC_FindHashedDefine(define_t **definehash, char *name)

-{

-	define_t *d;

-	int hash;

-

-	hash = PC_NameHash(name);

-	for (d = definehash[hash]; d; d = d->hashnext)

-	{

-		if (!strcmp(d->name, name)) return d;

-	} //end for

-	return NULL;

-} //end of the function PC_FindHashedDefine

-#endif //DEFINEHASHING

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-define_t *PC_FindDefine(define_t *defines, char *name)

-{

-	define_t *d;

-

-	for (d = defines; d; d = d->next)

-	{

-		if (!strcmp(d->name, name)) return d;

-	} //end for

-	return NULL;

-} //end of the function PC_FindDefine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					number of the parm

-//								if no parm found with the given name -1 is returned

-// Changes Globals:		-

-//============================================================================

-int PC_FindDefineParm(define_t *define, char *name)

-{

-	token_t *p;

-	int i;

-

-	i = 0;

-	for (p = define->parms; p; p = p->next)

-	{

-		if (!strcmp(p->string, name)) return i;

-		i++;

-	} //end for

-	return -1;

-} //end of the function PC_FindDefineParm

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_FreeDefine(define_t *define)

-{

-	token_t *t, *next;

-

-	//free the define parameters

-	for (t = define->parms; t; t = next)

-	{

-		next = t->next;

-		PC_FreeToken(t);

-	} //end for

-	//free the define tokens

-	for (t = define->tokens; t; t = next)

-	{

-		next = t->next;

-		PC_FreeToken(t);

-	} //end for

-	//free the define

-	FreeMemory(define);

-} //end of the function PC_FreeDefine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_AddBuiltinDefines(source_t *source)

-{

-	int i;

-	define_t *define;

-	struct builtin

-	{

-		char *string;

-		int builtin;

-	} builtin[] = { // bk001204 - brackets

-		{ "__LINE__",	BUILTIN_LINE },

-		{ "__FILE__",	BUILTIN_FILE },

-		{ "__DATE__",	BUILTIN_DATE },

-		{ "__TIME__",	BUILTIN_TIME },

-//		{ "__STDC__", BUILTIN_STDC },

-		{ NULL, 0 }

-	};

-

-	for (i = 0; builtin[i].string; i++)

-	{

-		define = (define_t *) GetMemory(sizeof(define_t) + strlen(builtin[i].string) + 1);

-		Com_Memset(define, 0, sizeof(define_t));

-		define->name = (char *) define + sizeof(define_t);

-		strcpy(define->name, builtin[i].string);

-		define->flags |= DEFINE_FIXED;

-		define->builtin = builtin[i].builtin;

-		//add the define to the source

-#if DEFINEHASHING

-		PC_AddDefineToHash(define, source->definehash);

-#else

-		define->next = source->defines;

-		source->defines = define;

-#endif //DEFINEHASHING

-	} //end for

-} //end of the function PC_AddBuiltinDefines

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpandBuiltinDefine(source_t *source, token_t *deftoken, define_t *define,

-										token_t **firsttoken, token_t **lasttoken)

-{

-	token_t *token;

-	unsigned long t;	//	time_t t; //to prevent LCC warning

-	char *curtime;

-

-	token = PC_CopyToken(deftoken);

-	switch(define->builtin)

-	{

-		case BUILTIN_LINE:

-		{

-			sprintf(token->string, "%d", deftoken->line);

-#ifdef NUMBERVALUE

-			token->intvalue = deftoken->line;

-			token->floatvalue = deftoken->line;

-#endif //NUMBERVALUE

-			token->type = TT_NUMBER;

-			token->subtype = TT_DECIMAL | TT_INTEGER;

-			*firsttoken = token;

-			*lasttoken = token;

-			break;

-		} //end case

-		case BUILTIN_FILE:

-		{

-			strcpy(token->string, source->scriptstack->filename);

-			token->type = TT_NAME;

-			token->subtype = strlen(token->string);

-			*firsttoken = token;

-			*lasttoken = token;

-			break;

-		} //end case

-		case BUILTIN_DATE:

-		{

-			t = time(NULL);

-			curtime = ctime(&t);

-			strcpy(token->string, "\"");

-			strncat(token->string, curtime+4, 7);

-			strncat(token->string+7, curtime+20, 4);

-			strcat(token->string, "\"");

-			free(curtime);

-			token->type = TT_NAME;

-			token->subtype = strlen(token->string);

-			*firsttoken = token;

-			*lasttoken = token;

-			break;

-		} //end case

-		case BUILTIN_TIME:

-		{

-			t = time(NULL);

-			curtime = ctime(&t);

-			strcpy(token->string, "\"");

-			strncat(token->string, curtime+11, 8);

-			strcat(token->string, "\"");

-			free(curtime);

-			token->type = TT_NAME;

-			token->subtype = strlen(token->string);

-			*firsttoken = token;

-			*lasttoken = token;

-			break;

-		} //end case

-		case BUILTIN_STDC:

-		default:

-		{

-			*firsttoken = NULL;

-			*lasttoken = NULL;

-			break;

-		} //end case

-	} //end switch

-	return qtrue;

-} //end of the function PC_ExpandBuiltinDefine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpandDefine(source_t *source, token_t *deftoken, define_t *define,

-										token_t **firsttoken, token_t **lasttoken)

-{

-	token_t *parms[MAX_DEFINEPARMS], *dt, *pt, *t;

-	token_t *t1, *t2, *first, *last, *nextpt, token;

-	int parmnum, i;

-

-	//if it is a builtin define

-	if (define->builtin)

-	{

-		return PC_ExpandBuiltinDefine(source, deftoken, define, firsttoken, lasttoken);

-	} //end if

-	//if the define has parameters

-	if (define->numparms)

-	{

-		if (!PC_ReadDefineParms(source, define, parms, MAX_DEFINEPARMS)) return qfalse;

-#ifdef DEBUG_EVAL

-		for (i = 0; i < define->numparms; i++)

-		{

-			Log_Write("define parms %d:", i);

-			for (pt = parms[i]; pt; pt = pt->next)

-			{

-				Log_Write("%s", pt->string);

-			} //end for

-		} //end for

-#endif //DEBUG_EVAL

-	} //end if

-	//empty list at first

-	first = NULL;

-	last = NULL;

-	//create a list with tokens of the expanded define

-	for (dt = define->tokens; dt; dt = dt->next)

-	{

-		parmnum = -1;

-		//if the token is a name, it could be a define parameter

-		if (dt->type == TT_NAME)

-		{

-			parmnum = PC_FindDefineParm(define, dt->string);

-		} //end if

-		//if it is a define parameter

-		if (parmnum >= 0)

-		{

-			for (pt = parms[parmnum]; pt; pt = pt->next)

-			{

-				t = PC_CopyToken(pt);

-				//add the token to the list

-				t->next = NULL;

-				if (last) last->next = t;

-				else first = t;

-				last = t;

-			} //end for

-		} //end if

-		else

-		{

-			//if stringizing operator

-			if (dt->string[0] == '#' && dt->string[1] == '\0')

-			{

-				//the stringizing operator must be followed by a define parameter

-				if (dt->next) parmnum = PC_FindDefineParm(define, dt->next->string);

-				else parmnum = -1;

-				//

-				if (parmnum >= 0)

-				{

-					//step over the stringizing operator

-					dt = dt->next;

-					//stringize the define parameter tokens

-					if (!PC_StringizeTokens(parms[parmnum], &token))

-					{

-						SourceError(source, "can't stringize tokens");

-						return qfalse;

-					} //end if

-					t = PC_CopyToken(&token);

-				} //end if

-				else

-				{

-					SourceWarning(source, "stringizing operator without define parameter");

-					continue;

-				} //end if

-			} //end if

-			else

-			{

-				t = PC_CopyToken(dt);

-			} //end else

-			//add the token to the list

-			t->next = NULL;

-			if (last) last->next = t;

-			else first = t;

-			last = t;

-		} //end else

-	} //end for

-	//check for the merging operator

-	for (t = first; t; )

-	{

-		if (t->next)

-		{

-			//if the merging operator

-			if (t->next->string[0] == '#' && t->next->string[1] == '#')

-			{

-				t1 = t;

-				t2 = t->next->next;

-				if (t2)

-				{

-					if (!PC_MergeTokens(t1, t2))

-					{

-						SourceError(source, "can't merge %s with %s", t1->string, t2->string);

-						return qfalse;

-					} //end if

-					PC_FreeToken(t1->next);

-					t1->next = t2->next;

-					if (t2 == last) last = t1;

-					PC_FreeToken(t2);

-					continue;

-				} //end if

-			} //end if

-		} //end if

-		t = t->next;

-	} //end for

-	//store the first and last token of the list

-	*firsttoken = first;

-	*lasttoken = last;

-	//free all the parameter tokens

-	for (i = 0; i < define->numparms; i++)

-	{

-		for (pt = parms[i]; pt; pt = nextpt)

-		{

-			nextpt = pt->next;

-			PC_FreeToken(pt);

-		} //end for

-	} //end for

-	//

-	return qtrue;

-} //end of the function PC_ExpandDefine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpandDefineIntoSource(source_t *source, token_t *deftoken, define_t *define)

-{

-	token_t *firsttoken, *lasttoken;

-

-	if (!PC_ExpandDefine(source, deftoken, define, &firsttoken, &lasttoken)) return qfalse;

-

-	if (firsttoken && lasttoken)

-	{

-		lasttoken->next = source->tokens;

-		source->tokens = firsttoken;

-		return qtrue;

-	} //end if

-	return qfalse;

-} //end of the function PC_ExpandDefineIntoSource

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_ConvertPath(char *path)

-{

-	char *ptr;

-

-	//remove double path seperators

-	for (ptr = path; *ptr;)

-	{

-		if ((*ptr == '\\' || *ptr == '/') &&

-				(*(ptr+1) == '\\' || *(ptr+1) == '/'))

-		{

-			strcpy(ptr, ptr+1);

-		} //end if

-		else

-		{

-			ptr++;

-		} //end else

-	} //end while

-	//set OS dependent path seperators

-	for (ptr = path; *ptr;)

-	{

-		if (*ptr == '/' || *ptr == '\\') *ptr = PATHSEPERATOR_CHAR;

-		ptr++;

-	} //end while

-} //end of the function PC_ConvertPath

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_include(source_t *source)

-{

-	script_t *script;

-	token_t token;

-	char path[MAX_PATH];

-#ifdef QUAKE

-	foundfile_t file;

-#endif //QUAKE

-

-	if (source->skip > 0) return qtrue;

-	//

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "#include without file name");

-		return qfalse;

-	} //end if

-	if (token.linescrossed > 0)

-	{

-		SourceError(source, "#include without file name");

-		return qfalse;

-	} //end if

-	if (token.type == TT_STRING)

-	{

-		StripDoubleQuotes(token.string);

-		PC_ConvertPath(token.string);

-		script = LoadScriptFile(token.string);

-		if (!script)

-		{

-			strcpy(path, source->includepath);

-			strcat(path, token.string);

-			script = LoadScriptFile(path);

-		} //end if

-	} //end if

-	else if (token.type == TT_PUNCTUATION && *token.string == '<')

-	{

-		strcpy(path, source->includepath);

-		while(PC_ReadSourceToken(source, &token))

-		{

-			if (token.linescrossed > 0)

-			{

-				PC_UnreadSourceToken(source, &token);

-				break;

-			} //end if

-			if (token.type == TT_PUNCTUATION && *token.string == '>') break;

-			strncat(path, token.string, MAX_PATH);

-		} //end while

-		if (*token.string != '>')

-		{

-			SourceWarning(source, "#include missing trailing >");

-		} //end if

-		if (!strlen(path))

-		{

-			SourceError(source, "#include without file name between < >");

-			return qfalse;

-		} //end if

-		PC_ConvertPath(path);

-		script = LoadScriptFile(path);

-	} //end if

-	else

-	{

-		SourceError(source, "#include without file name");

-		return qfalse;

-	} //end else

-#ifdef QUAKE

-	if (!script)

-	{

-		Com_Memset(&file, 0, sizeof(foundfile_t));

-		script = LoadScriptFile(path);

-		if (script) strncpy(script->filename, path, MAX_PATH);

-	} //end if

-#endif //QUAKE

-	if (!script)

-	{

-#ifdef SCREWUP

-		SourceWarning(source, "file %s not found", path);

-		return qtrue;

-#else

-		SourceError(source, "file %s not found", path);

-		return qfalse;

-#endif //SCREWUP

-	} //end if

-	PC_PushScript(source, script);

-	return qtrue;

-} //end of the function PC_Directive_include

-//============================================================================

-// reads a token from the current line, continues reading on the next

-// line only if a backslash '\' is encountered.

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ReadLine(source_t *source, token_t *token)

-{

-	int crossline;

-

-	crossline = 0;

-	do

-	{

-		if (!PC_ReadSourceToken(source, token)) return qfalse;

-		

-		if (token->linescrossed > crossline)

-		{

-			PC_UnreadSourceToken(source, token);

-			return qfalse;

-		} //end if

-		crossline = 1;

-	} while(!strcmp(token->string, "\\"));

-	return qtrue;

-} //end of the function PC_ReadLine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_WhiteSpaceBeforeToken(token_t *token)

-{

-	return token->endwhitespace_p - token->whitespace_p > 0;

-} //end of the function PC_WhiteSpaceBeforeToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_ClearTokenWhiteSpace(token_t *token)

-{

-	token->whitespace_p = NULL;

-	token->endwhitespace_p = NULL;

-	token->linescrossed = 0;

-} //end of the function PC_ClearTokenWhiteSpace

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_undef(source_t *source)

-{

-	token_t token;

-	define_t *define, *lastdefine;

-	int hash;

-

-	if (source->skip > 0) return qtrue;

-	//

-	if (!PC_ReadLine(source, &token))

-	{

-		SourceError(source, "undef without name");

-		return qfalse;

-	} //end if

-	if (token.type != TT_NAME)

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "expected name, found %s", token.string);

-		return qfalse;

-	} //end if

-#if DEFINEHASHING

-

-	hash = PC_NameHash(token.string);

-	for (lastdefine = NULL, define = source->definehash[hash]; define; define = define->hashnext)

-	{

-		if (!strcmp(define->name, token.string))

-		{

-			if (define->flags & DEFINE_FIXED)

-			{

-				SourceWarning(source, "can't undef %s", token.string);

-			} //end if

-			else

-			{

-				if (lastdefine) lastdefine->hashnext = define->hashnext;

-				else source->definehash[hash] = define->hashnext;

-				PC_FreeDefine(define);

-			} //end else

-			break;

-		} //end if

-		lastdefine = define;

-	} //end for

-#else //DEFINEHASHING

-	for (lastdefine = NULL, define = source->defines; define; define = define->next)

-	{

-		if (!strcmp(define->name, token.string))

-		{

-			if (define->flags & DEFINE_FIXED)

-			{

-				SourceWarning(source, "can't undef %s", token.string);

-			} //end if

-			else

-			{

-				if (lastdefine) lastdefine->next = define->next;

-				else source->defines = define->next;

-				PC_FreeDefine(define);

-			} //end else

-			break;

-		} //end if

-		lastdefine = define;

-	} //end for

-#endif //DEFINEHASHING

-	return qtrue;

-} //end of the function PC_Directive_undef

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_define(source_t *source)

-{

-	token_t token, *t, *last;

-	define_t *define;

-

-	if (source->skip > 0) return qtrue;

-	//

-	if (!PC_ReadLine(source, &token))

-	{

-		SourceError(source, "#define without name");

-		return qfalse;

-	} //end if

-	if (token.type != TT_NAME)

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "expected name after #define, found %s", token.string);

-		return qfalse;

-	} //end if

-	//check if the define already exists

-#if DEFINEHASHING

-	define = PC_FindHashedDefine(source->definehash, token.string);

-#else

-	define = PC_FindDefine(source->defines, token.string);

-#endif //DEFINEHASHING

-	if (define)

-	{

-		if (define->flags & DEFINE_FIXED)

-		{

-			SourceError(source, "can't redefine %s", token.string);

-			return qfalse;

-		} //end if

-		SourceWarning(source, "redefinition of %s", token.string);

-		//unread the define name before executing the #undef directive

-		PC_UnreadSourceToken(source, &token);

-		if (!PC_Directive_undef(source)) return qfalse;

-		//if the define was not removed (define->flags & DEFINE_FIXED)

-#if DEFINEHASHING

-		define = PC_FindHashedDefine(source->definehash, token.string);

-#else

-		define = PC_FindDefine(source->defines, token.string);

-#endif //DEFINEHASHING

-	} //end if

-	//allocate define

-	define = (define_t *) GetMemory(sizeof(define_t) + strlen(token.string) + 1);

-	Com_Memset(define, 0, sizeof(define_t));

-	define->name = (char *) define + sizeof(define_t);

-	strcpy(define->name, token.string);

-	//add the define to the source

-#if DEFINEHASHING

-	PC_AddDefineToHash(define, source->definehash);

-#else //DEFINEHASHING

-	define->next = source->defines;

-	source->defines = define;

-#endif //DEFINEHASHING

-	//if nothing is defined, just return

-	if (!PC_ReadLine(source, &token)) return qtrue;

-	//if it is a define with parameters

-	if (!PC_WhiteSpaceBeforeToken(&token) && !strcmp(token.string, "("))

-	{

-		//read the define parameters

-		last = NULL;

-		if (!PC_CheckTokenString(source, ")"))

-		{

-			while(1)

-			{

-				if (!PC_ReadLine(source, &token))

-				{

-					SourceError(source, "expected define parameter");

-					return qfalse;

-				} //end if

-				//if it isn't a name

-				if (token.type != TT_NAME)

-				{

-					SourceError(source, "invalid define parameter");

-					return qfalse;

-				} //end if

-				//

-				if (PC_FindDefineParm(define, token.string) >= 0)

-				{

-					SourceError(source, "two the same define parameters");

-					return qfalse;

-				} //end if

-				//add the define parm

-				t = PC_CopyToken(&token);

-				PC_ClearTokenWhiteSpace(t);

-				t->next = NULL;

-				if (last) last->next = t;

-				else define->parms = t;

-				last = t;

-				define->numparms++;

-				//read next token

-				if (!PC_ReadLine(source, &token))

-				{

-					SourceError(source, "define parameters not terminated");

-					return qfalse;

-				} //end if

-				//

-				if (!strcmp(token.string, ")")) break;

-				//then it must be a comma

-				if (strcmp(token.string, ","))

-				{

-					SourceError(source, "define not terminated");

-					return qfalse;

-				} //end if

-			} //end while

-		} //end if

-		if (!PC_ReadLine(source, &token)) return qtrue;

-	} //end if

-	//read the defined stuff

-	last = NULL;

-	do

-	{

-		t = PC_CopyToken(&token);

-		if (t->type == TT_NAME && !strcmp(t->string, define->name))

-		{

-			SourceError(source, "recursive define (removed recursion)");

-			continue;

-		} //end if

-		PC_ClearTokenWhiteSpace(t);

-		t->next = NULL;

-		if (last) last->next = t;

-		else define->tokens = t;

-		last = t;

-	} while(PC_ReadLine(source, &token));

-	//

-	if (last)

-	{

-		//check for merge operators at the beginning or end

-		if (!strcmp(define->tokens->string, "##") ||

-				!strcmp(last->string, "##"))

-		{

-			SourceError(source, "define with misplaced ##");

-			return qfalse;

-		} //end if

-	} //end if

-	return qtrue;

-} //end of the function PC_Directive_define

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-define_t *PC_DefineFromString(char *string)

-{

-	script_t *script;

-	source_t src;

-	token_t *t;

-	int res, i;

-	define_t *def;

-

-	PC_InitTokenHeap();

-

-	script = LoadScriptMemory(string, strlen(string), "*extern");

-	//create a new source

-	Com_Memset(&src, 0, sizeof(source_t));

-	strncpy(src.filename, "*extern", MAX_PATH);

-	src.scriptstack = script;

-#if DEFINEHASHING

-	src.definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));

-#endif //DEFINEHASHING

-	//create a define from the source

-	res = PC_Directive_define(&src);

-	//free any tokens if left

-	for (t = src.tokens; t; t = src.tokens)

-	{

-		src.tokens = src.tokens->next;

-		PC_FreeToken(t);

-	} //end for

-#ifdef DEFINEHASHING

-	def = NULL;

-	for (i = 0; i < DEFINEHASHSIZE; i++)

-	{

-		if (src.definehash[i])

-		{

-			def = src.definehash[i];

-			break;

-		} //end if

-	} //end for

-#else

-	def = src.defines;

-#endif //DEFINEHASHING

-	//

-#if DEFINEHASHING

-	FreeMemory(src.definehash);

-#endif //DEFINEHASHING

-	//

-	FreeScript(script);

-	//if the define was created succesfully

-	if (res > 0) return def;

-	//free the define is created

-	if (src.defines) PC_FreeDefine(def);

-	//

-	return NULL;

-} //end of the function PC_DefineFromString

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_AddDefine(source_t *source, char *string)

-{

-	define_t *define;

-

-	define = PC_DefineFromString(string);

-	if (!define) return qfalse;

-#if DEFINEHASHING

-	PC_AddDefineToHash(define, source->definehash);

-#else //DEFINEHASHING

-	define->next = source->defines;

-	source->defines = define;

-#endif //DEFINEHASHING

-	return qtrue;

-} //end of the function PC_AddDefine

-//============================================================================

-// add a globals define that will be added to all opened sources

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_AddGlobalDefine(char *string)

-{

-	define_t *define;

-

-	define = PC_DefineFromString(string);

-	if (!define) return qfalse;

-	define->next = globaldefines;

-	globaldefines = define;

-	return qtrue;

-} //end of the function PC_AddGlobalDefine

-//============================================================================

-// remove the given global define

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_RemoveGlobalDefine(char *name)

-{

-	define_t *define;

-

-	define = PC_FindDefine(globaldefines, name);

-	if (define)

-	{

-		PC_FreeDefine(define);

-		return qtrue;

-	} //end if

-	return qfalse;

-} //end of the function PC_RemoveGlobalDefine

-//============================================================================

-// remove all globals defines

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_RemoveAllGlobalDefines(void)

-{

-	define_t *define;

-

-	for (define = globaldefines; define; define = globaldefines)

-	{

-		globaldefines = globaldefines->next;

-		PC_FreeDefine(define);

-	} //end for

-} //end of the function PC_RemoveAllGlobalDefines

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-define_t *PC_CopyDefine(source_t *source, define_t *define)

-{

-	define_t *newdefine;

-	token_t *token, *newtoken, *lasttoken;

-

-	newdefine = (define_t *) GetMemory(sizeof(define_t) + strlen(define->name) + 1);

-	//copy the define name

-	newdefine->name = (char *) newdefine + sizeof(define_t);

-	strcpy(newdefine->name, define->name);

-	newdefine->flags = define->flags;

-	newdefine->builtin = define->builtin;

-	newdefine->numparms = define->numparms;

-	//the define is not linked

-	newdefine->next = NULL;

-	newdefine->hashnext = NULL;

-	//copy the define tokens

-	newdefine->tokens = NULL;

-	for (lasttoken = NULL, token = define->tokens; token; token = token->next)

-	{

-		newtoken = PC_CopyToken(token);

-		newtoken->next = NULL;

-		if (lasttoken) lasttoken->next = newtoken;

-		else newdefine->tokens = newtoken;

-		lasttoken = newtoken;

-	} //end for

-	//copy the define parameters

-	newdefine->parms = NULL;

-	for (lasttoken = NULL, token = define->parms; token; token = token->next)

-	{

-		newtoken = PC_CopyToken(token);

-		newtoken->next = NULL;

-		if (lasttoken) lasttoken->next = newtoken;

-		else newdefine->parms = newtoken;

-		lasttoken = newtoken;

-	} //end for

-	return newdefine;

-} //end of the function PC_CopyDefine

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_AddGlobalDefinesToSource(source_t *source)

-{

-	define_t *define, *newdefine;

-

-	for (define = globaldefines; define; define = define->next)

-	{

-		newdefine = PC_CopyDefine(source, define);

-#if DEFINEHASHING

-		PC_AddDefineToHash(newdefine, source->definehash);

-#else //DEFINEHASHING

-		newdefine->next = source->defines;

-		source->defines = newdefine;

-#endif //DEFINEHASHING

-	} //end for

-} //end of the function PC_AddGlobalDefinesToSource

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_if_def(source_t *source, int type)

-{

-	token_t token;

-	define_t *d;

-	int skip;

-

-	if (!PC_ReadLine(source, &token))

-	{

-		SourceError(source, "#ifdef without name");

-		return qfalse;

-	} //end if

-	if (token.type != TT_NAME)

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "expected name after #ifdef, found %s", token.string);

-		return qfalse;

-	} //end if

-#if DEFINEHASHING

-	d = PC_FindHashedDefine(source->definehash, token.string);

-#else

-	d = PC_FindDefine(source->defines, token.string);

-#endif //DEFINEHASHING

-	skip = (type == INDENT_IFDEF) == (d == NULL);

-	PC_PushIndent(source, type, skip);

-	return qtrue;

-} //end of the function PC_Directiveif_def

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_ifdef(source_t *source)

-{

-	return PC_Directive_if_def(source, INDENT_IFDEF);

-} //end of the function PC_Directive_ifdef

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_ifndef(source_t *source)

-{

-	return PC_Directive_if_def(source, INDENT_IFNDEF);

-} //end of the function PC_Directive_ifndef

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_else(source_t *source)

-{

-	int type, skip;

-

-	PC_PopIndent(source, &type, &skip);

-	if (!type)

-	{

-		SourceError(source, "misplaced #else");

-		return qfalse;

-	} //end if

-	if (type == INDENT_ELSE)

-	{

-		SourceError(source, "#else after #else");

-		return qfalse;

-	} //end if

-	PC_PushIndent(source, INDENT_ELSE, !skip);

-	return qtrue;

-} //end of the function PC_Directive_else

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_endif(source_t *source)

-{

-	int type, skip;

-

-	PC_PopIndent(source, &type, &skip);

-	if (!type)

-	{

-		SourceError(source, "misplaced #endif");

-		return qfalse;

-	} //end if

-	return qtrue;

-} //end of the function PC_Directive_endif

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-typedef struct operator_s

-{

-	int operator;

-	int priority;

-	int parentheses;

-	struct operator_s *prev, *next;

-} operator_t;

-

-typedef struct value_s

-{

-	signed long int intvalue;

-	double floatvalue;

-	int parentheses;

-	struct value_s *prev, *next;

-} value_t;

-

-int PC_OperatorPriority(int op)

-{

-	switch(op)

-	{

-		case P_MUL: return 15;

-		case P_DIV: return 15;

-		case P_MOD: return 15;

-		case P_ADD: return 14;

-		case P_SUB: return 14;

-

-		case P_LOGIC_AND: return 7;

-		case P_LOGIC_OR: return 6;

-		case P_LOGIC_GEQ: return 12;

-		case P_LOGIC_LEQ: return 12;

-		case P_LOGIC_EQ: return 11;

-		case P_LOGIC_UNEQ: return 11;

-

-		case P_LOGIC_NOT: return 16;

-		case P_LOGIC_GREATER: return 12;

-		case P_LOGIC_LESS: return 12;

-

-		case P_RSHIFT: return 13;

-		case P_LSHIFT: return 13;

-

-		case P_BIN_AND: return 10;

-		case P_BIN_OR: return 8;

-		case P_BIN_XOR: return 9;

-		case P_BIN_NOT: return 16;

-

-		case P_COLON: return 5;

-		case P_QUESTIONMARK: return 5;

-	} //end switch

-	return qfalse;

-} //end of the function PC_OperatorPriority

-

-//#define AllocValue()			GetClearedMemory(sizeof(value_t));

-//#define FreeValue(val)		FreeMemory(val)

-//#define AllocOperator(op)		op = (operator_t *) GetClearedMemory(sizeof(operator_t));

-//#define FreeOperator(op)		FreeMemory(op);

-

-#define MAX_VALUES		64

-#define MAX_OPERATORS	64

-#define AllocValue(val)									\

-	if (numvalues >= MAX_VALUES) {						\

-		SourceError(source, "out of value space\n");		\

-		error = 1;										\

-		break;											\

-	}													\

-	else												\

-		val = &value_heap[numvalues++];

-#define FreeValue(val)

-//

-#define AllocOperator(op)								\

-	if (numoperators >= MAX_OPERATORS) {				\

-		SourceError(source, "out of operator space\n");	\

-		error = 1;										\

-		break;											\

-	}													\

-	else												\

-		op = &operator_heap[numoperators++];

-#define FreeOperator(op)

-

-int PC_EvaluateTokens(source_t *source, token_t *tokens, signed long int *intvalue,

-																	double *floatvalue, int integer)

-{

-	operator_t *o, *firstoperator, *lastoperator;

-	value_t *v, *firstvalue, *lastvalue, *v1, *v2;

-	token_t *t;

-	int brace = 0;

-	int parentheses = 0;

-	int error = 0;

-	int lastwasvalue = 0;

-	int negativevalue = 0;

-	int questmarkintvalue = 0;

-	double questmarkfloatvalue = 0;

-	int gotquestmarkvalue = qfalse;

-	int lastoperatortype = 0;

-	//

-	operator_t operator_heap[MAX_OPERATORS];

-	int numoperators = 0;

-	value_t value_heap[MAX_VALUES];

-	int numvalues = 0;

-

-	firstoperator = lastoperator = NULL;

-	firstvalue = lastvalue = NULL;

-	if (intvalue) *intvalue = 0;

-	if (floatvalue) *floatvalue = 0;

-	for (t = tokens; t; t = t->next)

-	{

-		switch(t->type)

-		{

-			case TT_NAME:

-			{

-				if (lastwasvalue || negativevalue)

-				{

-					SourceError(source, "syntax error in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				if (strcmp(t->string, "defined"))

-				{

-					SourceError(source, "undefined name %s in #if/#elif", t->string);

-					error = 1;

-					break;

-				} //end if

-				t = t->next;

-				if (!strcmp(t->string, "("))

-				{

-					brace = qtrue;

-					t = t->next;

-				} //end if

-				if (!t || t->type != TT_NAME)

-				{

-					SourceError(source, "defined without name in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				//v = (value_t *) GetClearedMemory(sizeof(value_t));

-				AllocValue(v);

-#if DEFINEHASHING

-				if (PC_FindHashedDefine(source->definehash, t->string))

-#else			

-				if (PC_FindDefine(source->defines, t->string))

-#endif //DEFINEHASHING

-				{

-					v->intvalue = 1;

-					v->floatvalue = 1;

-				} //end if

-				else

-				{

-					v->intvalue = 0;

-					v->floatvalue = 0;

-				} //end else

-				v->parentheses = parentheses;

-				v->next = NULL;

-				v->prev = lastvalue;

-				if (lastvalue) lastvalue->next = v;

-				else firstvalue = v;

-				lastvalue = v;

-				if (brace)

-				{

-					t = t->next;

-					if (!t || strcmp(t->string, ")"))

-					{

-						SourceError(source, "defined without ) in #if/#elif");

-						error = 1;

-						break;

-					} //end if

-				} //end if

-				brace = qfalse;

-				// defined() creates a value

-				lastwasvalue = 1;

-				break;

-			} //end case

-			case TT_NUMBER:

-			{

-				if (lastwasvalue)

-				{

-					SourceError(source, "syntax error in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				//v = (value_t *) GetClearedMemory(sizeof(value_t));

-				AllocValue(v);

-				if (negativevalue)

-				{

-					v->intvalue = - (signed int) t->intvalue;

-					v->floatvalue = - t->floatvalue;

-				} //end if

-				else

-				{

-					v->intvalue = t->intvalue;

-					v->floatvalue = t->floatvalue;

-				} //end else

-				v->parentheses = parentheses;

-				v->next = NULL;

-				v->prev = lastvalue;

-				if (lastvalue) lastvalue->next = v;

-				else firstvalue = v;

-				lastvalue = v;

-				//last token was a value

-				lastwasvalue = 1;

-				//

-				negativevalue = 0;

-				break;

-			} //end case

-			case TT_PUNCTUATION:

-			{

-				if (negativevalue)

-				{

-					SourceError(source, "misplaced minus sign in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				if (t->subtype == P_PARENTHESESOPEN)

-				{

-					parentheses++;

-					break;

-				} //end if

-				else if (t->subtype == P_PARENTHESESCLOSE)

-				{

-					parentheses--;

-					if (parentheses < 0)

-					{

-						SourceError(source, "too many ) in #if/#elsif");

-						error = 1;

-					} //end if

-					break;

-				} //end else if

-				//check for invalid operators on floating point values

-				if (!integer)

-				{

-					if (t->subtype == P_BIN_NOT || t->subtype == P_MOD ||

-						t->subtype == P_RSHIFT || t->subtype == P_LSHIFT ||

-						t->subtype == P_BIN_AND || t->subtype == P_BIN_OR ||

-						t->subtype == P_BIN_XOR)

-					{

-						SourceError(source, "illigal operator %s on floating point operands\n", t->string);

-						error = 1;

-						break;

-					} //end if

-				} //end if

-				switch(t->subtype)

-				{

-					case P_LOGIC_NOT:

-					case P_BIN_NOT:

-					{

-						if (lastwasvalue)

-						{

-							SourceError(source, "! or ~ after value in #if/#elif");

-							error = 1;

-							break;

-						} //end if

-						break;

-					} //end case

-					case P_INC:

-					case P_DEC:

-					{

-						SourceError(source, "++ or -- used in #if/#elif");

-						break;

-					} //end case

-					case P_SUB:

-					{

-						if (!lastwasvalue)

-						{

-							negativevalue = 1;

-							break;

-						} //end if

-					} //end case

-					

-					case P_MUL:

-					case P_DIV:

-					case P_MOD:

-					case P_ADD:

-

-					case P_LOGIC_AND:

-					case P_LOGIC_OR:

-					case P_LOGIC_GEQ:

-					case P_LOGIC_LEQ:

-					case P_LOGIC_EQ:

-					case P_LOGIC_UNEQ:

-

-					case P_LOGIC_GREATER:

-					case P_LOGIC_LESS:

-

-					case P_RSHIFT:

-					case P_LSHIFT:

-

-					case P_BIN_AND:

-					case P_BIN_OR:

-					case P_BIN_XOR:

-

-					case P_COLON:

-					case P_QUESTIONMARK:

-					{

-						if (!lastwasvalue)

-						{

-							SourceError(source, "operator %s after operator in #if/#elif", t->string);

-							error = 1;

-							break;

-						} //end if

-						break;

-					} //end case

-					default:

-					{

-						SourceError(source, "invalid operator %s in #if/#elif", t->string);

-						error = 1;

-						break;

-					} //end default

-				} //end switch

-				if (!error && !negativevalue)

-				{

-					//o = (operator_t *) GetClearedMemory(sizeof(operator_t));

-					AllocOperator(o);

-					o->operator = t->subtype;

-					o->priority = PC_OperatorPriority(t->subtype);

-					o->parentheses = parentheses;

-					o->next = NULL;

-					o->prev = lastoperator;

-					if (lastoperator) lastoperator->next = o;

-					else firstoperator = o;

-					lastoperator = o;

-					lastwasvalue = 0;

-				} //end if

-				break;

-			} //end case

-			default:

-			{

-				SourceError(source, "unknown %s in #if/#elif", t->string);

-				error = 1;

-				break;

-			} //end default

-		} //end switch

-		if (error) break;

-	} //end for

-	if (!error)

-	{

-		if (!lastwasvalue)

-		{

-			SourceError(source, "trailing operator in #if/#elif");

-			error = 1;

-		} //end if

-		else if (parentheses)

-		{

-			SourceError(source, "too many ( in #if/#elif");

-			error = 1;

-		} //end else if

-	} //end if

-	//

-	gotquestmarkvalue = qfalse;

-	questmarkintvalue = 0;

-	questmarkfloatvalue = 0;

-	//while there are operators

-	while(!error && firstoperator)

-	{

-		v = firstvalue;

-		for (o = firstoperator; o->next; o = o->next)

-		{

-			//if the current operator is nested deeper in parentheses

-			//than the next operator

-			if (o->parentheses > o->next->parentheses) break;

-			//if the current and next operator are nested equally deep in parentheses

-			if (o->parentheses == o->next->parentheses)

-			{

-				//if the priority of the current operator is equal or higher

-				//than the priority of the next operator

-				if (o->priority >= o->next->priority) break;

-			} //end if

-			//if the arity of the operator isn't equal to 1

-			if (o->operator != P_LOGIC_NOT

-					&& o->operator != P_BIN_NOT) v = v->next;

-			//if there's no value or no next value

-			if (!v)

-			{

-				SourceError(source, "mising values in #if/#elif");

-				error = 1;

-				break;

-			} //end if

-		} //end for

-		if (error) break;

-		v1 = v;

-		v2 = v->next;

-#ifdef DEBUG_EVAL

-		if (integer)

-		{

-			Log_Write("operator %s, value1 = %d", PunctuationFromNum(source->scriptstack, o->operator), v1->intvalue);

-			if (v2) Log_Write("value2 = %d", v2->intvalue);

-		} //end if

-		else

-		{

-			Log_Write("operator %s, value1 = %f", PunctuationFromNum(source->scriptstack, o->operator), v1->floatvalue);

-			if (v2) Log_Write("value2 = %f", v2->floatvalue);

-		} //end else

-#endif //DEBUG_EVAL

-		switch(o->operator)

-		{

-			case P_LOGIC_NOT:		v1->intvalue = !v1->intvalue;

-									v1->floatvalue = !v1->floatvalue; break;

-			case P_BIN_NOT:			v1->intvalue = ~v1->intvalue;

-									break;

-			case P_MUL:				v1->intvalue *= v2->intvalue;

-									v1->floatvalue *= v2->floatvalue; break;

-			case P_DIV:				if (!v2->intvalue || !v2->floatvalue)

-									{

-										SourceError(source, "divide by zero in #if/#elif\n");

-										error = 1;

-										break;

-									}

-									v1->intvalue /= v2->intvalue;

-									v1->floatvalue /= v2->floatvalue; break;

-			case P_MOD:				if (!v2->intvalue)

-									{

-										SourceError(source, "divide by zero in #if/#elif\n");

-										error = 1;

-										break;

-									}

-									v1->intvalue %= v2->intvalue; break;

-			case P_ADD:				v1->intvalue += v2->intvalue;

-									v1->floatvalue += v2->floatvalue; break;

-			case P_SUB:				v1->intvalue -= v2->intvalue;

-									v1->floatvalue -= v2->floatvalue; break;

-			case P_LOGIC_AND:		v1->intvalue = v1->intvalue && v2->intvalue;

-									v1->floatvalue = v1->floatvalue && v2->floatvalue; break;

-			case P_LOGIC_OR:		v1->intvalue = v1->intvalue || v2->intvalue;

-									v1->floatvalue = v1->floatvalue || v2->floatvalue; break;

-			case P_LOGIC_GEQ:		v1->intvalue = v1->intvalue >= v2->intvalue;

-									v1->floatvalue = v1->floatvalue >= v2->floatvalue; break;

-			case P_LOGIC_LEQ:		v1->intvalue = v1->intvalue <= v2->intvalue;

-									v1->floatvalue = v1->floatvalue <= v2->floatvalue; break;

-			case P_LOGIC_EQ:		v1->intvalue = v1->intvalue == v2->intvalue;

-									v1->floatvalue = v1->floatvalue == v2->floatvalue; break;

-			case P_LOGIC_UNEQ:		v1->intvalue = v1->intvalue != v2->intvalue;

-									v1->floatvalue = v1->floatvalue != v2->floatvalue; break;

-			case P_LOGIC_GREATER:	v1->intvalue = v1->intvalue > v2->intvalue;

-									v1->floatvalue = v1->floatvalue > v2->floatvalue; break;

-			case P_LOGIC_LESS:		v1->intvalue = v1->intvalue < v2->intvalue;

-									v1->floatvalue = v1->floatvalue < v2->floatvalue; break;

-			case P_RSHIFT:			v1->intvalue >>= v2->intvalue;

-									break;

-			case P_LSHIFT:			v1->intvalue <<= v2->intvalue;

-									break;

-			case P_BIN_AND:			v1->intvalue &= v2->intvalue;

-									break;

-			case P_BIN_OR:			v1->intvalue |= v2->intvalue;

-									break;

-			case P_BIN_XOR:			v1->intvalue ^= v2->intvalue;

-									break;

-			case P_COLON:

-			{

-				if (!gotquestmarkvalue)

-				{

-					SourceError(source, ": without ? in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				if (integer)

-				{

-					if (!questmarkintvalue) v1->intvalue = v2->intvalue;

-				} //end if

-				else

-				{

-					if (!questmarkfloatvalue) v1->floatvalue = v2->floatvalue;

-				} //end else

-				gotquestmarkvalue = qfalse;

-				break;

-			} //end case

-			case P_QUESTIONMARK:

-			{

-				if (gotquestmarkvalue)

-				{

-					SourceError(source, "? after ? in #if/#elif");

-					error = 1;

-					break;

-				} //end if

-				questmarkintvalue = v1->intvalue;

-				questmarkfloatvalue = v1->floatvalue;

-				gotquestmarkvalue = qtrue;

-				break;

-			} //end if

-		} //end switch

-#ifdef DEBUG_EVAL

-		if (integer) Log_Write("result value = %d", v1->intvalue);

-		else Log_Write("result value = %f", v1->floatvalue);

-#endif //DEBUG_EVAL

-		if (error) break;

-		lastoperatortype = o->operator;

-		//if not an operator with arity 1

-		if (o->operator != P_LOGIC_NOT

-				&& o->operator != P_BIN_NOT)

-		{

-			//remove the second value if not question mark operator

-			if (o->operator != P_QUESTIONMARK) v = v->next;

-			//

-			if (v->prev) v->prev->next = v->next;

-			else firstvalue = v->next;

-			if (v->next) v->next->prev = v->prev;

-			else lastvalue = v->prev;

-			//FreeMemory(v);

-			FreeValue(v);

-		} //end if

-		//remove the operator

-		if (o->prev) o->prev->next = o->next;

-		else firstoperator = o->next;

-		if (o->next) o->next->prev = o->prev;

-		else lastoperator = o->prev;

-		//FreeMemory(o);

-		FreeOperator(o);

-	} //end while

-	if (firstvalue)

-	{

-		if (intvalue) *intvalue = firstvalue->intvalue;

-		if (floatvalue) *floatvalue = firstvalue->floatvalue;

-	} //end if

-	for (o = firstoperator; o; o = lastoperator)

-	{

-		lastoperator = o->next;

-		//FreeMemory(o);

-		FreeOperator(o);

-	} //end for

-	for (v = firstvalue; v; v = lastvalue)

-	{

-		lastvalue = v->next;

-		//FreeMemory(v);

-		FreeValue(v);

-	} //end for

-	if (!error) return qtrue;

-	if (intvalue) *intvalue = 0;

-	if (floatvalue) *floatvalue = 0;

-	return qfalse;

-} //end of the function PC_EvaluateTokens

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Evaluate(source_t *source, signed long int *intvalue,

-												double *floatvalue, int integer)

-{

-	token_t token, *firsttoken, *lasttoken;

-	token_t *t, *nexttoken;

-	define_t *define;

-	int defined = qfalse;

-

-	if (intvalue) *intvalue = 0;

-	if (floatvalue) *floatvalue = 0;

-	//

-	if (!PC_ReadLine(source, &token))

-	{

-		SourceError(source, "no value after #if/#elif");

-		return qfalse;

-	} //end if

-	firsttoken = NULL;

-	lasttoken = NULL;

-	do

-	{

-		//if the token is a name

-		if (token.type == TT_NAME)

-		{

-			if (defined)

-			{

-				defined = qfalse;

-				t = PC_CopyToken(&token);

-				t->next = NULL;

-				if (lasttoken) lasttoken->next = t;

-				else firsttoken = t;

-				lasttoken = t;

-			} //end if

-			else if (!strcmp(token.string, "defined"))

-			{

-				defined = qtrue;

-				t = PC_CopyToken(&token);

-				t->next = NULL;

-				if (lasttoken) lasttoken->next = t;

-				else firsttoken = t;

-				lasttoken = t;

-			} //end if

-			else

-			{

-				//then it must be a define

-#if DEFINEHASHING

-				define = PC_FindHashedDefine(source->definehash, token.string);

-#else

-				define = PC_FindDefine(source->defines, token.string);

-#endif //DEFINEHASHING

-				if (!define)

-				{

-					SourceError(source, "can't evaluate %s, not defined", token.string);

-					return qfalse;

-				} //end if

-				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;

-			} //end else

-		} //end if

-		//if the token is a number or a punctuation

-		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)

-		{

-			t = PC_CopyToken(&token);

-			t->next = NULL;

-			if (lasttoken) lasttoken->next = t;

-			else firsttoken = t;

-			lasttoken = t;

-		} //end else

-		else //can't evaluate the token

-		{

-			SourceError(source, "can't evaluate %s", token.string);

-			return qfalse;

-		} //end else

-	} while(PC_ReadLine(source, &token));

-	//

-	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;

-	//

-#ifdef DEBUG_EVAL

-	Log_Write("eval:");

-#endif //DEBUG_EVAL

-	for (t = firsttoken; t; t = nexttoken)

-	{

-#ifdef DEBUG_EVAL

-		Log_Write(" %s", t->string);

-#endif //DEBUG_EVAL

-		nexttoken = t->next;

-		PC_FreeToken(t);

-	} //end for

-#ifdef DEBUG_EVAL

-	if (integer) Log_Write("eval result: %d", *intvalue);

-	else Log_Write("eval result: %f", *floatvalue);

-#endif //DEBUG_EVAL

-	//

-	return qtrue;

-} //end of the function PC_Evaluate

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_DollarEvaluate(source_t *source, signed long int *intvalue,

-												double *floatvalue, int integer)

-{

-	int indent, defined = qfalse;

-	token_t token, *firsttoken, *lasttoken;

-	token_t *t, *nexttoken;

-	define_t *define;

-

-	if (intvalue) *intvalue = 0;

-	if (floatvalue) *floatvalue = 0;

-	//

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "no leading ( after $evalint/$evalfloat");

-		return qfalse;

-	} //end if

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "nothing to evaluate");

-		return qfalse;

-	} //end if

-	indent = 1;

-	firsttoken = NULL;

-	lasttoken = NULL;

-	do

-	{

-		//if the token is a name

-		if (token.type == TT_NAME)

-		{

-			if (defined)

-			{

-				defined = qfalse;

-				t = PC_CopyToken(&token);

-				t->next = NULL;

-				if (lasttoken) lasttoken->next = t;

-				else firsttoken = t;

-				lasttoken = t;

-			} //end if

-			else if (!strcmp(token.string, "defined"))

-			{

-				defined = qtrue;

-				t = PC_CopyToken(&token);

-				t->next = NULL;

-				if (lasttoken) lasttoken->next = t;

-				else firsttoken = t;

-				lasttoken = t;

-			} //end if

-			else

-			{

-				//then it must be a define

-#if DEFINEHASHING

-				define = PC_FindHashedDefine(source->definehash, token.string);

-#else

-				define = PC_FindDefine(source->defines, token.string);

-#endif //DEFINEHASHING

-				if (!define)

-				{

-					SourceError(source, "can't evaluate %s, not defined", token.string);

-					return qfalse;

-				} //end if

-				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;

-			} //end else

-		} //end if

-		//if the token is a number or a punctuation

-		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)

-		{

-			if (*token.string == '(') indent++;

-			else if (*token.string == ')') indent--;

-			if (indent <= 0) break;

-			t = PC_CopyToken(&token);

-			t->next = NULL;

-			if (lasttoken) lasttoken->next = t;

-			else firsttoken = t;

-			lasttoken = t;

-		} //end else

-		else //can't evaluate the token

-		{

-			SourceError(source, "can't evaluate %s", token.string);

-			return qfalse;

-		} //end else

-	} while(PC_ReadSourceToken(source, &token));

-	//

-	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;

-	//

-#ifdef DEBUG_EVAL

-	Log_Write("$eval:");

-#endif //DEBUG_EVAL

-	for (t = firsttoken; t; t = nexttoken)

-	{

-#ifdef DEBUG_EVAL

-		Log_Write(" %s", t->string);

-#endif //DEBUG_EVAL

-		nexttoken = t->next;

-		PC_FreeToken(t);

-	} //end for

-#ifdef DEBUG_EVAL

-	if (integer) Log_Write("$eval result: %d", *intvalue);

-	else Log_Write("$eval result: %f", *floatvalue);

-#endif //DEBUG_EVAL

-	//

-	return qtrue;

-} //end of the function PC_DollarEvaluate

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_elif(source_t *source)

-{

-	signed long int value;

-	int type, skip;

-

-	PC_PopIndent(source, &type, &skip);

-	if (!type || type == INDENT_ELSE)

-	{

-		SourceError(source, "misplaced #elif");

-		return qfalse;

-	} //end if

-	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;

-	skip = (value == 0);

-	PC_PushIndent(source, INDENT_ELIF, skip);

-	return qtrue;

-} //end of the function PC_Directive_elif

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_if(source_t *source)

-{

-	signed long int value;

-	int skip;

-

-	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;

-	skip = (value == 0);

-	PC_PushIndent(source, INDENT_IF, skip);

-	return qtrue;

-} //end of the function PC_Directive

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_line(source_t *source)

-{

-	SourceError(source, "#line directive not supported");

-	return qfalse;

-} //end of the function PC_Directive_line

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_error(source_t *source)

-{

-	token_t token;

-

-	strcpy(token.string, "");

-	PC_ReadSourceToken(source, &token);

-	SourceError(source, "#error directive: %s", token.string);

-	return qfalse;

-} //end of the function PC_Directive_error

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_pragma(source_t *source)

-{

-	token_t token;

-

-	SourceWarning(source, "#pragma directive not supported");

-	while(PC_ReadLine(source, &token)) ;

-	return qtrue;

-} //end of the function PC_Directive_pragma

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void UnreadSignToken(source_t *source)

-{

-	token_t token;

-

-	token.line = source->scriptstack->line;

-	token.whitespace_p = source->scriptstack->script_p;

-	token.endwhitespace_p = source->scriptstack->script_p;

-	token.linescrossed = 0;

-	strcpy(token.string, "-");

-	token.type = TT_PUNCTUATION;

-	token.subtype = P_SUB;

-	PC_UnreadSourceToken(source, &token);

-} //end of the function UnreadSignToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_eval(source_t *source)

-{

-	signed long int value;

-	token_t token;

-

-	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;

-	//

-	token.line = source->scriptstack->line;

-	token.whitespace_p = source->scriptstack->script_p;

-	token.endwhitespace_p = source->scriptstack->script_p;

-	token.linescrossed = 0;

-	sprintf(token.string, "%d", abs(value));

-	token.type = TT_NUMBER;

-	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;

-	PC_UnreadSourceToken(source, &token);

-	if (value < 0) UnreadSignToken(source);

-	return qtrue;

-} //end of the function PC_Directive_eval

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_Directive_evalfloat(source_t *source)

-{

-	double value;

-	token_t token;

-

-	if (!PC_Evaluate(source, NULL, &value, qfalse)) return qfalse;

-	token.line = source->scriptstack->line;

-	token.whitespace_p = source->scriptstack->script_p;

-	token.endwhitespace_p = source->scriptstack->script_p;

-	token.linescrossed = 0;

-	sprintf(token.string, "%1.2f", fabs(value));

-	token.type = TT_NUMBER;

-	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;

-	PC_UnreadSourceToken(source, &token);

-	if (value < 0) UnreadSignToken(source);

-	return qtrue;

-} //end of the function PC_Directive_evalfloat

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-directive_t directives[20] =

-{

-	{"if", PC_Directive_if},

-	{"ifdef", PC_Directive_ifdef},

-	{"ifndef", PC_Directive_ifndef},

-	{"elif", PC_Directive_elif},

-	{"else", PC_Directive_else},

-	{"endif", PC_Directive_endif},

-	{"include", PC_Directive_include},

-	{"define", PC_Directive_define},

-	{"undef", PC_Directive_undef},

-	{"line", PC_Directive_line},

-	{"error", PC_Directive_error},

-	{"pragma", PC_Directive_pragma},

-	{"eval", PC_Directive_eval},

-	{"evalfloat", PC_Directive_evalfloat},

-	{NULL, NULL}

-};

-

-int PC_ReadDirective(source_t *source)

-{

-	token_t token;

-	int i;

-

-	//read the directive name

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "found # without name");

-		return qfalse;

-	} //end if

-	//directive name must be on the same line

-	if (token.linescrossed > 0)

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "found # at end of line");

-		return qfalse;

-	} //end if

-	//if if is a name

-	if (token.type == TT_NAME)

-	{

-		//find the precompiler directive

-		for (i = 0; directives[i].name; i++)

-		{

-			if (!strcmp(directives[i].name, token.string))

-			{

-				return directives[i].func(source);

-			} //end if

-		} //end for

-	} //end if

-	SourceError(source, "unknown precompiler directive %s", token.string);

-	return qfalse;

-} //end of the function PC_ReadDirective

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_DollarDirective_evalint(source_t *source)

-{

-	signed long int value;

-	token_t token;

-

-	if (!PC_DollarEvaluate(source, &value, NULL, qtrue)) return qfalse;

-	//

-	token.line = source->scriptstack->line;

-	token.whitespace_p = source->scriptstack->script_p;

-	token.endwhitespace_p = source->scriptstack->script_p;

-	token.linescrossed = 0;

-	sprintf(token.string, "%d", abs(value));

-	token.type = TT_NUMBER;

-	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;

-#ifdef NUMBERVALUE

-	token.intvalue = value;

-	token.floatvalue = value;

-#endif //NUMBERVALUE

-	PC_UnreadSourceToken(source, &token);

-	if (value < 0) UnreadSignToken(source);

-	return qtrue;

-} //end of the function PC_DollarDirective_evalint

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_DollarDirective_evalfloat(source_t *source)

-{

-	double value;

-	token_t token;

-

-	if (!PC_DollarEvaluate(source, NULL, &value, qfalse)) return qfalse;

-	token.line = source->scriptstack->line;

-	token.whitespace_p = source->scriptstack->script_p;

-	token.endwhitespace_p = source->scriptstack->script_p;

-	token.linescrossed = 0;

-	sprintf(token.string, "%1.2f", fabs(value));

-	token.type = TT_NUMBER;

-	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;

-#ifdef NUMBERVALUE

-	token.intvalue = (unsigned long) value;

-	token.floatvalue = value;

-#endif //NUMBERVALUE

-	PC_UnreadSourceToken(source, &token);

-	if (value < 0) UnreadSignToken(source);

-	return qtrue;

-} //end of the function PC_DollarDirective_evalfloat

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-directive_t dollardirectives[20] =

-{

-	{"evalint", PC_DollarDirective_evalint},

-	{"evalfloat", PC_DollarDirective_evalfloat},

-	{NULL, NULL}

-};

-

-int PC_ReadDollarDirective(source_t *source)

-{

-	token_t token;

-	int i;

-

-	//read the directive name

-	if (!PC_ReadSourceToken(source, &token))

-	{

-		SourceError(source, "found $ without name");

-		return qfalse;

-	} //end if

-	//directive name must be on the same line

-	if (token.linescrossed > 0)

-	{

-		PC_UnreadSourceToken(source, &token);

-		SourceError(source, "found $ at end of line");

-		return qfalse;

-	} //end if

-	//if if is a name

-	if (token.type == TT_NAME)

-	{

-		//find the precompiler directive

-		for (i = 0; dollardirectives[i].name; i++)

-		{

-			if (!strcmp(dollardirectives[i].name, token.string))

-			{

-				return dollardirectives[i].func(source);

-			} //end if

-		} //end for

-	} //end if

-	PC_UnreadSourceToken(source, &token);

-	SourceError(source, "unknown precompiler directive %s", token.string);

-	return qfalse;

-} //end of the function PC_ReadDirective

-

-#ifdef QUAKEC

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int BuiltinFunction(source_t *source)

-{

-	token_t token;

-

-	if (!PC_ReadSourceToken(source, &token)) return qfalse;

-	if (token.type == TT_NUMBER)

-	{

-		PC_UnreadSourceToken(source, &token);

-		return qtrue;

-	} //end if

-	else

-	{

-		PC_UnreadSourceToken(source, &token);

-		return qfalse;

-	} //end else

-} //end of the function BuiltinFunction

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int QuakeCMacro(source_t *source)

-{

-	int i;

-	token_t token;

-

-	if (!PC_ReadSourceToken(source, &token)) return qtrue;

-	if (token.type != TT_NAME)

-	{

-		PC_UnreadSourceToken(source, &token);

-		return qtrue;

-	} //end if

-	//find the precompiler directive

-	for (i = 0; dollardirectives[i].name; i++)

-	{

-		if (!strcmp(dollardirectives[i].name, token.string))

-		{

-			PC_UnreadSourceToken(source, &token);

-			return qfalse;

-		} //end if

-	} //end for

-	PC_UnreadSourceToken(source, &token);

-	return qtrue;

-} //end of the function QuakeCMacro

-#endif //QUAKEC

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ReadToken(source_t *source, token_t *token)

-{

-	define_t *define;

-

-	while(1)

-	{

-		if (!PC_ReadSourceToken(source, token)) return qfalse;

-		//check for precompiler directives

-		if (token->type == TT_PUNCTUATION && *token->string == '#')

-		{

-#ifdef QUAKEC

-			if (!BuiltinFunction(source))

-#endif //QUAKC

-			{

-				//read the precompiler directive

-				if (!PC_ReadDirective(source)) return qfalse;

-				continue;

-			} //end if

-		} //end if

-		if (token->type == TT_PUNCTUATION && *token->string == '$')

-		{

-#ifdef QUAKEC

-			if (!QuakeCMacro(source))

-#endif //QUAKEC

-			{

-				//read the precompiler directive

-				if (!PC_ReadDollarDirective(source)) return qfalse;

-				continue;

-			} //end if

-		} //end if

-		// recursively concatenate strings that are behind each other still resolving defines

-		if (token->type == TT_STRING)

-		{

-			token_t newtoken;

-			if (PC_ReadToken(source, &newtoken))

-			{

-				if (newtoken.type == TT_STRING)

-				{

-					token->string[strlen(token->string)-1] = '\0';

-					if (strlen(token->string) + strlen(newtoken.string+1) + 1 >= MAX_TOKEN)

-					{

-						SourceError(source, "string longer than MAX_TOKEN %d\n", MAX_TOKEN);

-						return qfalse;

-					}

-					strcat(token->string, newtoken.string+1);

-				}

-				else

-				{

-					PC_UnreadToken(source, &newtoken);

-				}

-			}

-		} //end if

-		//if skipping source because of conditional compilation

-		if (source->skip) continue;

-		//if the token is a name

-		if (token->type == TT_NAME)

-		{

-			//check if the name is a define macro

-#if DEFINEHASHING

-			define = PC_FindHashedDefine(source->definehash, token->string);

-#else

-			define = PC_FindDefine(source->defines, token->string);

-#endif //DEFINEHASHING

-			//if it is a define macro

-			if (define)

-			{

-				//expand the defined macro

-				if (!PC_ExpandDefineIntoSource(source, token, define)) return qfalse;

-				continue;

-			} //end if

-		} //end if

-		//copy token for unreading

-		Com_Memcpy(&source->token, token, sizeof(token_t));

-		//found a token

-		return qtrue;

-	} //end while

-} //end of the function PC_ReadToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpectTokenString(source_t *source, char *string)

-{

-	token_t token;

-

-	if (!PC_ReadToken(source, &token))

-	{

-		SourceError(source, "couldn't find expected %s", string);

-		return qfalse;

-	} //end if

-

-	if (strcmp(token.string, string))

-	{

-		SourceError(source, "expected %s, found %s", string, token.string);

-		return qfalse;

-	} //end if

-	return qtrue;

-} //end of the function PC_ExpectTokenString

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpectTokenType(source_t *source, int type, int subtype, token_t *token)

-{

-	char str[MAX_TOKEN];

-

-	if (!PC_ReadToken(source, token))

-	{

-		SourceError(source, "couldn't read expected token");

-		return qfalse;

-	} //end if

-

-	if (token->type != type)

-	{

-		strcpy(str, "");

-		if (type == TT_STRING) strcpy(str, "string");

-		if (type == TT_LITERAL) strcpy(str, "literal");

-		if (type == TT_NUMBER) strcpy(str, "number");

-		if (type == TT_NAME) strcpy(str, "name");

-		if (type == TT_PUNCTUATION) strcpy(str, "punctuation");

-		SourceError(source, "expected a %s, found %s", str, token->string);

-		return qfalse;

-	} //end if

-	if (token->type == TT_NUMBER)

-	{

-		if ((token->subtype & subtype) != subtype)

-		{

-			if (subtype & TT_DECIMAL) strcpy(str, "decimal");

-			if (subtype & TT_HEX) strcpy(str, "hex");

-			if (subtype & TT_OCTAL) strcpy(str, "octal");

-			if (subtype & TT_BINARY) strcpy(str, "binary");

-			if (subtype & TT_LONG) strcat(str, " long");

-			if (subtype & TT_UNSIGNED) strcat(str, " unsigned");

-			if (subtype & TT_FLOAT) strcat(str, " float");

-			if (subtype & TT_INTEGER) strcat(str, " integer");

-			SourceError(source, "expected %s, found %s", str, token->string);

-			return qfalse;

-		} //end if

-	} //end if

-	else if (token->type == TT_PUNCTUATION)

-	{

-		if (token->subtype != subtype)

-		{

-			SourceError(source, "found %s", token->string);

-			return qfalse;

-		} //end if

-	} //end else if

-	return qtrue;

-} //end of the function PC_ExpectTokenType

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_ExpectAnyToken(source_t *source, token_t *token)

-{

-	if (!PC_ReadToken(source, token))

-	{

-		SourceError(source, "couldn't read expected token");

-		return qfalse;

-	} //end if

-	else

-	{

-		return qtrue;

-	} //end else

-} //end of the function PC_ExpectAnyToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_CheckTokenString(source_t *source, char *string)

-{

-	token_t tok;

-

-	if (!PC_ReadToken(source, &tok)) return qfalse;

-	//if the token is available

-	if (!strcmp(tok.string, string)) return qtrue;

-	//

-	PC_UnreadSourceToken(source, &tok);

-	return qfalse;

-} //end of the function PC_CheckTokenString

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_CheckTokenType(source_t *source, int type, int subtype, token_t *token)

-{

-	token_t tok;

-

-	if (!PC_ReadToken(source, &tok)) return qfalse;

-	//if the type matches

-	if (tok.type == type &&

-			(tok.subtype & subtype) == subtype)

-	{

-		Com_Memcpy(token, &tok, sizeof(token_t));

-		return qtrue;

-	} //end if

-	//

-	PC_UnreadSourceToken(source, &tok);

-	return qfalse;

-} //end of the function PC_CheckTokenType

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-int PC_SkipUntilString(source_t *source, char *string)

-{

-	token_t token;

-

-	while(PC_ReadToken(source, &token))

-	{

-		if (!strcmp(token.string, string)) return qtrue;

-	} //end while

-	return qfalse;

-} //end of the function PC_SkipUntilString

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_UnreadLastToken(source_t *source)

-{

-	PC_UnreadSourceToken(source, &source->token);

-} //end of the function PC_UnreadLastToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_UnreadToken(source_t *source, token_t *token)

-{

-	PC_UnreadSourceToken(source, token);

-} //end of the function PC_UnreadToken

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_SetIncludePath(source_t *source, char *path)

-{

-	strncpy(source->includepath, path, MAX_PATH);

-	//add trailing path seperator

-	if (source->includepath[strlen(source->includepath)-1] != '\\' &&

-		source->includepath[strlen(source->includepath)-1] != '/')

-	{

-		strcat(source->includepath, PATHSEPERATOR_STR);

-	} //end if

-} //end of the function PC_SetIncludePath

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void PC_SetPunctuations(source_t *source, punctuation_t *p)

-{

-	source->punctuations = p;

-} //end of the function PC_SetPunctuations

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-source_t *LoadSourceFile(const char *filename)

-{

-	source_t *source;

-	script_t *script;

-

-	PC_InitTokenHeap();

-

-	script = LoadScriptFile(filename);

-	if (!script) return NULL;

-

-	script->next = NULL;

-

-	source = (source_t *) GetMemory(sizeof(source_t));

-	Com_Memset(source, 0, sizeof(source_t));

-

-	strncpy(source->filename, filename, MAX_PATH);

-	source->scriptstack = script;

-	source->tokens = NULL;

-	source->defines = NULL;

-	source->indentstack = NULL;

-	source->skip = 0;

-

-#if DEFINEHASHING

-	source->definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));

-#endif //DEFINEHASHING

-	PC_AddGlobalDefinesToSource(source);

-	return source;

-} //end of the function LoadSourceFile

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-source_t *LoadSourceMemory(char *ptr, int length, char *name)

-{

-	source_t *source;

-	script_t *script;

-

-	PC_InitTokenHeap();

-

-	script = LoadScriptMemory(ptr, length, name);

-	if (!script) return NULL;

-	script->next = NULL;

-

-	source = (source_t *) GetMemory(sizeof(source_t));

-	Com_Memset(source, 0, sizeof(source_t));

-

-	strncpy(source->filename, name, MAX_PATH);

-	source->scriptstack = script;

-	source->tokens = NULL;

-	source->defines = NULL;

-	source->indentstack = NULL;

-	source->skip = 0;

-

-#if DEFINEHASHING

-	source->definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));

-#endif //DEFINEHASHING

-	PC_AddGlobalDefinesToSource(source);

-	return source;

-} //end of the function LoadSourceMemory

-//============================================================================

-//

-// Parameter:				-

-// Returns:					-

-// Changes Globals:		-

-//============================================================================

-void FreeSource(source_t *source)

-{

-	script_t *script;

-	token_t *token;

-	define_t *define;

-	indent_t *indent;

-	int i;

-

-	//PC_PrintDefineHashTable(source->definehash);

-	//free all the scripts

-	while(source->scriptstack)

-	{

-		script = source->scriptstack;

-		source->scriptstack = source->scriptstack->next;

-		FreeScript(script);

-	} //end for

-	//free all the tokens

-	while(source->tokens)

-	{

-		token = source->tokens;

-		source->tokens = source->tokens->next;

-		PC_FreeToken(token);

-	} //end for

-#if DEFINEHASHING

-	for (i = 0; i < DEFINEHASHSIZE; i++)

-	{

-		while(source->definehash[i])

-		{

-			define = source->definehash[i];

-			source->definehash[i] = source->definehash[i]->hashnext;

-			PC_FreeDefine(define);

-		} //end while

-	} //end for

-#else //DEFINEHASHING

-	//free all defines

-	while(source->defines)

-	{

-		define = source->defines;

-		source->defines = source->defines->next;

-		PC_FreeDefine(define);

-	} //end for

-#endif //DEFINEHASHING

-	//free all indents

-	while(source->indentstack)

-	{

-		indent = source->indentstack;

-		source->indentstack = source->indentstack->next;

-		FreeMemory(indent);

-	} //end for

-#if DEFINEHASHING

-	//

-	if (source->definehash) FreeMemory(source->definehash);

-#endif //DEFINEHASHING

-	//free the source itself

-	FreeMemory(source);

-} //end of the function FreeSource

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-

-#define MAX_SOURCEFILES		64

-

-source_t *sourceFiles[MAX_SOURCEFILES];

-

-int PC_LoadSourceHandle(const char *filename)

-{

-	source_t *source;

-	int i;

-

-	for (i = 1; i < MAX_SOURCEFILES; i++)

-	{

-		if (!sourceFiles[i])

-			break;

-	} //end for

-	if (i >= MAX_SOURCEFILES)

-		return 0;

-	PS_SetBaseFolder("");

-	source = LoadSourceFile(filename);

-	if (!source)

-		return 0;

-	sourceFiles[i] = source;

-	return i;

-} //end of the function PC_LoadSourceHandle

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-int PC_FreeSourceHandle(int handle)

-{

-	if (handle < 1 || handle >= MAX_SOURCEFILES)

-		return qfalse;

-	if (!sourceFiles[handle])

-		return qfalse;

-

-	FreeSource(sourceFiles[handle]);

-	sourceFiles[handle] = NULL;

-	return qtrue;

-} //end of the function PC_FreeSourceHandle

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-int PC_ReadTokenHandle(int handle, pc_token_t *pc_token)

-{

-	token_t token;

-	int ret;

-

-	if (handle < 1 || handle >= MAX_SOURCEFILES)

-		return 0;

-	if (!sourceFiles[handle])

-		return 0;

-

-	ret = PC_ReadToken(sourceFiles[handle], &token);

-	strcpy(pc_token->string, token.string);

-	pc_token->type = token.type;

-	pc_token->subtype = token.subtype;

-	pc_token->intvalue = token.intvalue;

-	pc_token->floatvalue = token.floatvalue;

-	if (pc_token->type == TT_STRING)

-		StripDoubleQuotes(pc_token->string);

-	return ret;

-} //end of the function PC_ReadTokenHandle

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-int PC_SourceFileAndLine(int handle, char *filename, int *line)

-{

-	if (handle < 1 || handle >= MAX_SOURCEFILES)

-		return qfalse;

-	if (!sourceFiles[handle])

-		return qfalse;

-

-	strcpy(filename, sourceFiles[handle]->filename);

-	if (sourceFiles[handle]->scriptstack)

-		*line = sourceFiles[handle]->scriptstack->line;

-	else

-		*line = 0;

-	return qtrue;

-} //end of the function PC_SourceFileAndLine

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-void PC_SetBaseFolder(char *path)

-{

-	PS_SetBaseFolder(path);

-} //end of the function PC_SetBaseFolder

-//============================================================================

-//

-// Parameter:			-

-// Returns:				-

-// Changes Globals:		-

-//============================================================================

-void PC_CheckOpenSourceHandles(void)

-{

-	int i;

-

-	for (i = 1; i < MAX_SOURCEFILES; i++)

-	{

-		if (sourceFiles[i])

-		{

-#ifdef BOTLIB

-			botimport.Print(PRT_ERROR, "file %s still open in precompiler\n", sourceFiles[i]->scriptstack->filename);

-#endif	//BOTLIB

-		} //end if

-	} //end for

-} //end of the function PC_CheckOpenSourceHandles

-

+/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+
+This file is part of Quake III Arena source code.
+
+Quake III Arena source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Quake III Arena source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Foobar; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+//
+
+/*****************************************************************************
+ * name:		l_precomp.c
+ *
+ * desc:		pre compiler
+ *
+ * $Archive: /MissionPack/code/botlib/l_precomp.c $
+ *
+ *****************************************************************************/
+
+//Notes:			fix: PC_StringizeTokens
+
+//#define SCREWUP
+//#define BOTLIB
+//#define QUAKE
+//#define QUAKEC
+//#define MEQCC
+
+#ifdef SCREWUP
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <stdarg.h>
+#include <time.h>
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+
+typedef enum {qfalse, qtrue}	qboolean;
+#endif //SCREWUP
+
+#ifdef BOTLIB
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "be_interface.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_log.h"
+#endif //BOTLIB
+
+#ifdef MEQCC
+#include "qcc.h"
+#include "time.h"   //time & ctime
+#include "math.h"   //fabs
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_log.h"
+
+#define qtrue	true
+#define qfalse	false
+#endif //MEQCC
+
+#ifdef BSPC
+//include files for usage in the BSP Converter
+#include "../bspc/qbsp.h"
+#include "../bspc/l_log.h"
+#include "../bspc/l_mem.h"
+#include "l_precomp.h"
+
+#define qtrue	true
+#define qfalse	false
+#define Q_stricmp	stricmp
+
+#endif //BSPC
+
+#if defined(QUAKE) && !defined(BSPC)
+#include "l_utils.h"
+#endif //QUAKE
+
+//#define DEBUG_EVAL
+
+#define MAX_DEFINEPARMS			128
+
+#define DEFINEHASHING			1
+
+//directive name with parse function
+typedef struct directive_s
+{
+	char *name;
+	int (*func)(source_t *source);
+} directive_t;
+
+#define DEFINEHASHSIZE		1024
+
+#define TOKEN_HEAP_SIZE		4096
+
+int numtokens;
+/*
+int tokenheapinitialized;				//true when the token heap is initialized
+token_t token_heap[TOKEN_HEAP_SIZE];	//heap with tokens
+token_t *freetokens;					//free tokens from the heap
+*/
+
+//list with global defines added to every source loaded
+define_t *globaldefines;
+
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void QDECL SourceError(source_t *source, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_ERROR, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif	//BOTLIB
+#ifdef MEQCC
+	printf("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BSPC
+} //end of the function SourceError
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL SourceWarning(source_t *source, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_WARNING, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BOTLIB
+#ifdef MEQCC
+	printf("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BSPC
+} //end of the function ScriptWarning
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PushIndent(source_t *source, int type, int skip)
+{
+	indent_t *indent;
+
+	indent = (indent_t *) GetMemory(sizeof(indent_t));
+	indent->type = type;
+	indent->script = source->scriptstack;
+	indent->skip = (skip != 0);
+	source->skip += indent->skip;
+	indent->next = source->indentstack;
+	source->indentstack = indent;
+} //end of the function PC_PushIndent
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PopIndent(source_t *source, int *type, int *skip)
+{
+	indent_t *indent;
+
+	*type = 0;
+	*skip = 0;
+
+	indent = source->indentstack;
+	if (!indent) return;
+
+	//must be an indent from the current script
+	if (source->indentstack->script != source->scriptstack) return;
+
+	*type = indent->type;
+	*skip = indent->skip;
+	source->indentstack = source->indentstack->next;
+	source->skip -= indent->skip;
+	FreeMemory(indent);
+} //end of the function PC_PopIndent
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PushScript(source_t *source, script_t *script)
+{
+	script_t *s;
+
+	for (s = source->scriptstack; s; s = s->next)
+	{
+		if (!Q_stricmp(s->filename, script->filename))
+		{
+			SourceError(source, "%s recursively included", script->filename);
+			return;
+		} //end if
+	} //end for
+	//push the script on the script stack
+	script->next = source->scriptstack;
+	source->scriptstack = script;
+} //end of the function PC_PushScript
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_InitTokenHeap(void)
+{
+	/*
+	int i;
+
+	if (tokenheapinitialized) return;
+	freetokens = NULL;
+	for (i = 0; i < TOKEN_HEAP_SIZE; i++)
+	{
+		token_heap[i].next = freetokens;
+		freetokens = &token_heap[i];
+	} //end for
+	tokenheapinitialized = qtrue;
+	*/
+} //end of the function PC_InitTokenHeap
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+token_t *PC_CopyToken(token_t *token)
+{
+	token_t *t;
+
+//	t = (token_t *) malloc(sizeof(token_t));
+	t = (token_t *) GetMemory(sizeof(token_t));
+//	t = freetokens;
+	if (!t)
+	{
+#ifdef BSPC
+		Error("out of token space\n");
+#else
+		Com_Error(ERR_FATAL, "out of token space\n");
+#endif
+		return NULL;
+	} //end if
+//	freetokens = freetokens->next;
+	Com_Memcpy(t, token, sizeof(token_t));
+	t->next = NULL;
+	numtokens++;
+	return t;
+} //end of the function PC_CopyToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_FreeToken(token_t *token)
+{
+	//free(token);
+	FreeMemory(token);
+//	token->next = freetokens;
+//	freetokens = token;
+	numtokens--;
+} //end of the function PC_FreeToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadSourceToken(source_t *source, token_t *token)
+{
+	token_t *t;
+	script_t *script;
+	int type, skip;
+
+	//if there's no token already available
+	while(!source->tokens)
+	{
+		//if there's a token to read from the script
+		if (PS_ReadToken(source->scriptstack, token)) return qtrue;
+		//if at the end of the script
+		if (EndOfScript(source->scriptstack))
+		{
+			//remove all indents of the script
+			while(source->indentstack &&
+					source->indentstack->script == source->scriptstack)
+			{
+				SourceWarning(source, "missing #endif");
+				PC_PopIndent(source, &type, &skip);
+			} //end if
+		} //end if
+		//if this was the initial script
+		if (!source->scriptstack->next) return qfalse;
+		//remove the script and return to the last one
+		script = source->scriptstack;
+		source->scriptstack = source->scriptstack->next;
+		FreeScript(script);
+	} //end while
+	//copy the already available token
+	Com_Memcpy(token, source->tokens, sizeof(token_t));
+	//free the read token
+	t = source->tokens;
+	source->tokens = source->tokens->next;
+	PC_FreeToken(t);
+	return qtrue;
+} //end of the function PC_ReadSourceToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_UnreadSourceToken(source_t *source, token_t *token)
+{
+	token_t *t;
+
+	t = PC_CopyToken(token);
+	t->next = source->tokens;
+	source->tokens = t;
+	return qtrue;
+} //end of the function PC_UnreadSourceToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadDefineParms(source_t *source, define_t *define, token_t **parms, int maxparms)
+{
+	token_t token, *t, *last;
+	int i, done, lastcomma, numparms, indent;
+
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "define %s missing parms", define->name);
+		return qfalse;
+	} //end if
+	//
+	if (define->numparms > maxparms)
+	{
+		SourceError(source, "define with more than %d parameters", maxparms);
+		return qfalse;
+	} //end if
+	//
+	for (i = 0; i < define->numparms; i++) parms[i] = NULL;
+	//if no leading "("
+	if (strcmp(token.string, "("))
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "define %s missing parms", define->name);
+		return qfalse;
+	} //end if
+	//read the define parameters
+	for (done = 0, numparms = 0, indent = 0; !done;)
+	{
+		if (numparms >= maxparms)
+		{
+			SourceError(source, "define %s with too many parms", define->name);
+			return qfalse;
+		} //end if
+		if (numparms >= define->numparms)
+		{
+			SourceWarning(source, "define %s has too many parms", define->name);
+			return qfalse;
+		} //end if
+		parms[numparms] = NULL;
+		lastcomma = 1;
+		last = NULL;
+		while(!done)
+		{
+			//
+			if (!PC_ReadSourceToken(source, &token))
+			{
+				SourceError(source, "define %s incomplete", define->name);
+				return qfalse;
+			} //end if
+			//
+			if (!strcmp(token.string, ","))
+			{
+				if (indent <= 0)
+				{
+					if (lastcomma) SourceWarning(source, "too many comma's");
+					lastcomma = 1;
+					break;
+				} //end if
+			} //end if
+			lastcomma = 0;
+			//
+			if (!strcmp(token.string, "("))
+			{
+				indent++;
+				continue;
+			} //end if
+			else if (!strcmp(token.string, ")"))
+			{
+				if (--indent <= 0)
+				{
+					if (!parms[define->numparms-1])
+					{
+						SourceWarning(source, "too few define parms");
+					} //end if
+					done = 1;
+					break;
+				} //end if
+			} //end if
+			//
+			if (numparms < define->numparms)
+			{
+				//
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (last) last->next = t;
+				else parms[numparms] = t;
+				last = t;
+			} //end if
+		} //end while
+		numparms++;
+	} //end for
+	return qtrue;
+} //end of the function PC_ReadDefineParms
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_StringizeTokens(token_t *tokens, token_t *token)
+{
+	token_t *t;
+
+	token->type = TT_STRING;
+	token->whitespace_p = NULL;
+	token->endwhitespace_p = NULL;
+	token->string[0] = '\0';
+	strcat(token->string, "\"");
+	for (t = tokens; t; t = t->next)
+	{
+		strncat(token->string, t->string, MAX_TOKEN - strlen(token->string));
+	} //end for
+	strncat(token->string, "\"", MAX_TOKEN - strlen(token->string));
+	return qtrue;
+} //end of the function PC_StringizeTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_MergeTokens(token_t *t1, token_t *t2)
+{
+	//merging of a name with a name or number
+	if (t1->type == TT_NAME && (t2->type == TT_NAME || t2->type == TT_NUMBER))
+	{
+		strcat(t1->string, t2->string);
+		return qtrue;
+	} //end if
+	//merging of two strings
+	if (t1->type == TT_STRING && t2->type == TT_STRING)
+	{
+		//remove trailing double quote
+		t1->string[strlen(t1->string)-1] = '\0';
+		//concat without leading double quote
+		strcat(t1->string, &t2->string[1]);
+		return qtrue;
+	} //end if
+	//FIXME: merging of two number of the same sub type
+	return qfalse;
+} //end of the function PC_MergeTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+/*
+void PC_PrintDefine(define_t *define)
+{
+	printf("define->name = %s\n", define->name);
+	printf("define->flags = %d\n", define->flags);
+	printf("define->builtin = %d\n", define->builtin);
+	printf("define->numparms = %d\n", define->numparms);
+//	token_t *parms;					//define parameters
+//	token_t *tokens;					//macro tokens (possibly containing parm tokens)
+//	struct define_s *next;			//next defined macro in a list
+} //end of the function PC_PrintDefine*/
+#if DEFINEHASHING
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PrintDefineHashTable(define_t **definehash)
+{
+	int i;
+	define_t *d;
+
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		Log_Write("%4d:", i);
+		for (d = definehash[i]; d; d = d->hashnext)
+		{
+			Log_Write(" %s", d->name);
+		} //end for
+		Log_Write("\n");
+	} //end for
+} //end of the function PC_PrintDefineHashTable
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+//char primes[16] = {1, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 41, 43, 47};
+
+int PC_NameHash(char *name)
+{
+	int register hash, i;
+
+	hash = 0;
+	for (i = 0; name[i] != '\0'; i++)
+	{
+		hash += name[i] * (119 + i);
+		//hash += (name[i] << 7) + i;
+		//hash += (name[i] << (i&15));
+	} //end while
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (DEFINEHASHSIZE-1);
+	return hash;
+} //end of the function PC_NameHash
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddDefineToHash(define_t *define, define_t **definehash)
+{
+	int hash;
+
+	hash = PC_NameHash(define->name);
+	define->hashnext = definehash[hash];
+	definehash[hash] = define;
+} //end of the function PC_AddDefineToHash
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_FindHashedDefine(define_t **definehash, char *name)
+{
+	define_t *d;
+	int hash;
+
+	hash = PC_NameHash(name);
+	for (d = definehash[hash]; d; d = d->hashnext)
+	{
+		if (!strcmp(d->name, name)) return d;
+	} //end for
+	return NULL;
+} //end of the function PC_FindHashedDefine
+#endif //DEFINEHASHING
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_FindDefine(define_t *defines, char *name)
+{
+	define_t *d;
+
+	for (d = defines; d; d = d->next)
+	{
+		if (!strcmp(d->name, name)) return d;
+	} //end for
+	return NULL;
+} //end of the function PC_FindDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					number of the parm
+//								if no parm found with the given name -1 is returned
+// Changes Globals:		-
+//============================================================================
+int PC_FindDefineParm(define_t *define, char *name)
+{
+	token_t *p;
+	int i;
+
+	i = 0;
+	for (p = define->parms; p; p = p->next)
+	{
+		if (!strcmp(p->string, name)) return i;
+		i++;
+	} //end for
+	return -1;
+} //end of the function PC_FindDefineParm
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_FreeDefine(define_t *define)
+{
+	token_t *t, *next;
+
+	//free the define parameters
+	for (t = define->parms; t; t = next)
+	{
+		next = t->next;
+		PC_FreeToken(t);
+	} //end for
+	//free the define tokens
+	for (t = define->tokens; t; t = next)
+	{
+		next = t->next;
+		PC_FreeToken(t);
+	} //end for
+	//free the define
+	FreeMemory(define);
+} //end of the function PC_FreeDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddBuiltinDefines(source_t *source)
+{
+	int i;
+	define_t *define;
+	struct builtin
+	{
+		char *string;
+		int builtin;
+	} builtin[] = { // bk001204 - brackets
+		{ "__LINE__",	BUILTIN_LINE },
+		{ "__FILE__",	BUILTIN_FILE },
+		{ "__DATE__",	BUILTIN_DATE },
+		{ "__TIME__",	BUILTIN_TIME },
+//		{ "__STDC__", BUILTIN_STDC },
+		{ NULL, 0 }
+	};
+
+	for (i = 0; builtin[i].string; i++)
+	{
+		define = (define_t *) GetMemory(sizeof(define_t) + strlen(builtin[i].string) + 1);
+		Com_Memset(define, 0, sizeof(define_t));
+		define->name = (char *) define + sizeof(define_t);
+		strcpy(define->name, builtin[i].string);
+		define->flags |= DEFINE_FIXED;
+		define->builtin = builtin[i].builtin;
+		//add the define to the source
+#if DEFINEHASHING
+		PC_AddDefineToHash(define, source->definehash);
+#else
+		define->next = source->defines;
+		source->defines = define;
+#endif //DEFINEHASHING
+	} //end for
+} //end of the function PC_AddBuiltinDefines
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandBuiltinDefine(source_t *source, token_t *deftoken, define_t *define,
+										token_t **firsttoken, token_t **lasttoken)
+{
+	token_t *token;
+	unsigned long t;	//	time_t t; //to prevent LCC warning
+	char *curtime;
+
+	token = PC_CopyToken(deftoken);
+	switch(define->builtin)
+	{
+		case BUILTIN_LINE:
+		{
+			sprintf(token->string, "%d", deftoken->line);
+#ifdef NUMBERVALUE
+			token->intvalue = deftoken->line;
+			token->floatvalue = deftoken->line;
+#endif //NUMBERVALUE
+			token->type = TT_NUMBER;
+			token->subtype = TT_DECIMAL | TT_INTEGER;
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_FILE:
+		{
+			strcpy(token->string, source->scriptstack->filename);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_DATE:
+		{
+			t = time(NULL);
+			curtime = ctime(&t);
+			strcpy(token->string, "\"");
+			strncat(token->string, curtime+4, 7);
+			strncat(token->string+7, curtime+20, 4);
+			strcat(token->string, "\"");
+			free(curtime);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_TIME:
+		{
+			t = time(NULL);
+			curtime = ctime(&t);
+			strcpy(token->string, "\"");
+			strncat(token->string, curtime+11, 8);
+			strcat(token->string, "\"");
+			free(curtime);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_STDC:
+		default:
+		{
+			*firsttoken = NULL;
+			*lasttoken = NULL;
+			break;
+		} //end case
+	} //end switch
+	return qtrue;
+} //end of the function PC_ExpandBuiltinDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandDefine(source_t *source, token_t *deftoken, define_t *define,
+										token_t **firsttoken, token_t **lasttoken)
+{
+	token_t *parms[MAX_DEFINEPARMS], *dt, *pt, *t;
+	token_t *t1, *t2, *first, *last, *nextpt, token;
+	int parmnum, i;
+
+	//if it is a builtin define
+	if (define->builtin)
+	{
+		return PC_ExpandBuiltinDefine(source, deftoken, define, firsttoken, lasttoken);
+	} //end if
+	//if the define has parameters
+	if (define->numparms)
+	{
+		if (!PC_ReadDefineParms(source, define, parms, MAX_DEFINEPARMS)) return qfalse;
+#ifdef DEBUG_EVAL
+		for (i = 0; i < define->numparms; i++)
+		{
+			Log_Write("define parms %d:", i);
+			for (pt = parms[i]; pt; pt = pt->next)
+			{
+				Log_Write("%s", pt->string);
+			} //end for
+		} //end for
+#endif //DEBUG_EVAL
+	} //end if
+	//empty list at first
+	first = NULL;
+	last = NULL;
+	//create a list with tokens of the expanded define
+	for (dt = define->tokens; dt; dt = dt->next)
+	{
+		parmnum = -1;
+		//if the token is a name, it could be a define parameter
+		if (dt->type == TT_NAME)
+		{
+			parmnum = PC_FindDefineParm(define, dt->string);
+		} //end if
+		//if it is a define parameter
+		if (parmnum >= 0)
+		{
+			for (pt = parms[parmnum]; pt; pt = pt->next)
+			{
+				t = PC_CopyToken(pt);
+				//add the token to the list
+				t->next = NULL;
+				if (last) last->next = t;
+				else first = t;
+				last = t;
+			} //end for
+		} //end if
+		else
+		{
+			//if stringizing operator
+			if (dt->string[0] == '#' && dt->string[1] == '\0')
+			{
+				//the stringizing operator must be followed by a define parameter
+				if (dt->next) parmnum = PC_FindDefineParm(define, dt->next->string);
+				else parmnum = -1;
+				//
+				if (parmnum >= 0)
+				{
+					//step over the stringizing operator
+					dt = dt->next;
+					//stringize the define parameter tokens
+					if (!PC_StringizeTokens(parms[parmnum], &token))
+					{
+						SourceError(source, "can't stringize tokens");
+						return qfalse;
+					} //end if
+					t = PC_CopyToken(&token);
+				} //end if
+				else
+				{
+					SourceWarning(source, "stringizing operator without define parameter");
+					continue;
+				} //end if
+			} //end if
+			else
+			{
+				t = PC_CopyToken(dt);
+			} //end else
+			//add the token to the list
+			t->next = NULL;
+			if (last) last->next = t;
+			else first = t;
+			last = t;
+		} //end else
+	} //end for
+	//check for the merging operator
+	for (t = first; t; )
+	{
+		if (t->next)
+		{
+			//if the merging operator
+			if (t->next->string[0] == '#' && t->next->string[1] == '#')
+			{
+				t1 = t;
+				t2 = t->next->next;
+				if (t2)
+				{
+					if (!PC_MergeTokens(t1, t2))
+					{
+						SourceError(source, "can't merge %s with %s", t1->string, t2->string);
+						return qfalse;
+					} //end if
+					PC_FreeToken(t1->next);
+					t1->next = t2->next;
+					if (t2 == last) last = t1;
+					PC_FreeToken(t2);
+					continue;
+				} //end if
+			} //end if
+		} //end if
+		t = t->next;
+	} //end for
+	//store the first and last token of the list
+	*firsttoken = first;
+	*lasttoken = last;
+	//free all the parameter tokens
+	for (i = 0; i < define->numparms; i++)
+	{
+		for (pt = parms[i]; pt; pt = nextpt)
+		{
+			nextpt = pt->next;
+			PC_FreeToken(pt);
+		} //end for
+	} //end for
+	//
+	return qtrue;
+} //end of the function PC_ExpandDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandDefineIntoSource(source_t *source, token_t *deftoken, define_t *define)
+{
+	token_t *firsttoken, *lasttoken;
+
+	if (!PC_ExpandDefine(source, deftoken, define, &firsttoken, &lasttoken)) return qfalse;
+
+	if (firsttoken && lasttoken)
+	{
+		lasttoken->next = source->tokens;
+		source->tokens = firsttoken;
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function PC_ExpandDefineIntoSource
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_ConvertPath(char *path)
+{
+	char *ptr;
+
+	//remove double path seperators
+	for (ptr = path; *ptr;)
+	{
+		if ((*ptr == '\\' || *ptr == '/') &&
+				(*(ptr+1) == '\\' || *(ptr+1) == '/'))
+		{
+			strcpy(ptr, ptr+1);
+		} //end if
+		else
+		{
+			ptr++;
+		} //end else
+	} //end while
+	//set OS dependent path seperators
+	for (ptr = path; *ptr;)
+	{
+		if (*ptr == '/' || *ptr == '\\') *ptr = PATHSEPERATOR_CHAR;
+		ptr++;
+	} //end while
+} //end of the function PC_ConvertPath
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_include(source_t *source)
+{
+	script_t *script;
+	token_t token;
+	char path[MAX_PATH];
+#ifdef QUAKE
+	foundfile_t file;
+#endif //QUAKE
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end if
+	if (token.linescrossed > 0)
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end if
+	if (token.type == TT_STRING)
+	{
+		StripDoubleQuotes(token.string);
+		PC_ConvertPath(token.string);
+		script = LoadScriptFile(token.string);
+		if (!script)
+		{
+			strcpy(path, source->includepath);
+			strcat(path, token.string);
+			script = LoadScriptFile(path);
+		} //end if
+	} //end if
+	else if (token.type == TT_PUNCTUATION && *token.string == '<')
+	{
+		strcpy(path, source->includepath);
+		while(PC_ReadSourceToken(source, &token))
+		{
+			if (token.linescrossed > 0)
+			{
+				PC_UnreadSourceToken(source, &token);
+				break;
+			} //end if
+			if (token.type == TT_PUNCTUATION && *token.string == '>') break;
+			strncat(path, token.string, MAX_PATH);
+		} //end while
+		if (*token.string != '>')
+		{
+			SourceWarning(source, "#include missing trailing >");
+		} //end if
+		if (!strlen(path))
+		{
+			SourceError(source, "#include without file name between < >");
+			return qfalse;
+		} //end if
+		PC_ConvertPath(path);
+		script = LoadScriptFile(path);
+	} //end if
+	else
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end else
+#ifdef QUAKE
+	if (!script)
+	{
+		Com_Memset(&file, 0, sizeof(foundfile_t));
+		script = LoadScriptFile(path);
+		if (script) strncpy(script->filename, path, MAX_PATH);
+	} //end if
+#endif //QUAKE
+	if (!script)
+	{
+#ifdef SCREWUP
+		SourceWarning(source, "file %s not found", path);
+		return qtrue;
+#else
+		SourceError(source, "file %s not found", path);
+		return qfalse;
+#endif //SCREWUP
+	} //end if
+	PC_PushScript(source, script);
+	return qtrue;
+} //end of the function PC_Directive_include
+//============================================================================
+// reads a token from the current line, continues reading on the next
+// line only if a backslash '\' is encountered.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadLine(source_t *source, token_t *token)
+{
+	int crossline;
+
+	crossline = 0;
+	do
+	{
+		if (!PC_ReadSourceToken(source, token)) return qfalse;
+		
+		if (token->linescrossed > crossline)
+		{
+			PC_UnreadSourceToken(source, token);
+			return qfalse;
+		} //end if
+		crossline = 1;
+	} while(!strcmp(token->string, "\\"));
+	return qtrue;
+} //end of the function PC_ReadLine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_WhiteSpaceBeforeToken(token_t *token)
+{
+	return token->endwhitespace_p - token->whitespace_p > 0;
+} //end of the function PC_WhiteSpaceBeforeToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_ClearTokenWhiteSpace(token_t *token)
+{
+	token->whitespace_p = NULL;
+	token->endwhitespace_p = NULL;
+	token->linescrossed = 0;
+} //end of the function PC_ClearTokenWhiteSpace
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_undef(source_t *source)
+{
+	token_t token;
+	define_t *define, *lastdefine;
+	int hash;
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "undef without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name, found %s", token.string);
+		return qfalse;
+	} //end if
+#if DEFINEHASHING
+
+	hash = PC_NameHash(token.string);
+	for (lastdefine = NULL, define = source->definehash[hash]; define; define = define->hashnext)
+	{
+		if (!strcmp(define->name, token.string))
+		{
+			if (define->flags & DEFINE_FIXED)
+			{
+				SourceWarning(source, "can't undef %s", token.string);
+			} //end if
+			else
+			{
+				if (lastdefine) lastdefine->hashnext = define->hashnext;
+				else source->definehash[hash] = define->hashnext;
+				PC_FreeDefine(define);
+			} //end else
+			break;
+		} //end if
+		lastdefine = define;
+	} //end for
+#else //DEFINEHASHING
+	for (lastdefine = NULL, define = source->defines; define; define = define->next)
+	{
+		if (!strcmp(define->name, token.string))
+		{
+			if (define->flags & DEFINE_FIXED)
+			{
+				SourceWarning(source, "can't undef %s", token.string);
+			} //end if
+			else
+			{
+				if (lastdefine) lastdefine->next = define->next;
+				else source->defines = define->next;
+				PC_FreeDefine(define);
+			} //end else
+			break;
+		} //end if
+		lastdefine = define;
+	} //end for
+#endif //DEFINEHASHING
+	return qtrue;
+} //end of the function PC_Directive_undef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_define(source_t *source)
+{
+	token_t token, *t, *last;
+	define_t *define;
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "#define without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name after #define, found %s", token.string);
+		return qfalse;
+	} //end if
+	//check if the define already exists
+#if DEFINEHASHING
+	define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+	define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	if (define)
+	{
+		if (define->flags & DEFINE_FIXED)
+		{
+			SourceError(source, "can't redefine %s", token.string);
+			return qfalse;
+		} //end if
+		SourceWarning(source, "redefinition of %s", token.string);
+		//unread the define name before executing the #undef directive
+		PC_UnreadSourceToken(source, &token);
+		if (!PC_Directive_undef(source)) return qfalse;
+		//if the define was not removed (define->flags & DEFINE_FIXED)
+#if DEFINEHASHING
+		define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+		define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	} //end if
+	//allocate define
+	define = (define_t *) GetMemory(sizeof(define_t) + strlen(token.string) + 1);
+	Com_Memset(define, 0, sizeof(define_t));
+	define->name = (char *) define + sizeof(define_t);
+	strcpy(define->name, token.string);
+	//add the define to the source
+#if DEFINEHASHING
+	PC_AddDefineToHash(define, source->definehash);
+#else //DEFINEHASHING
+	define->next = source->defines;
+	source->defines = define;
+#endif //DEFINEHASHING
+	//if nothing is defined, just return
+	if (!PC_ReadLine(source, &token)) return qtrue;
+	//if it is a define with parameters
+	if (!PC_WhiteSpaceBeforeToken(&token) && !strcmp(token.string, "("))
+	{
+		//read the define parameters
+		last = NULL;
+		if (!PC_CheckTokenString(source, ")"))
+		{
+			while(1)
+			{
+				if (!PC_ReadLine(source, &token))
+				{
+					SourceError(source, "expected define parameter");
+					return qfalse;
+				} //end if
+				//if it isn't a name
+				if (token.type != TT_NAME)
+				{
+					SourceError(source, "invalid define parameter");
+					return qfalse;
+				} //end if
+				//
+				if (PC_FindDefineParm(define, token.string) >= 0)
+				{
+					SourceError(source, "two the same define parameters");
+					return qfalse;
+				} //end if
+				//add the define parm
+				t = PC_CopyToken(&token);
+				PC_ClearTokenWhiteSpace(t);
+				t->next = NULL;
+				if (last) last->next = t;
+				else define->parms = t;
+				last = t;
+				define->numparms++;
+				//read next token
+				if (!PC_ReadLine(source, &token))
+				{
+					SourceError(source, "define parameters not terminated");
+					return qfalse;
+				} //end if
+				//
+				if (!strcmp(token.string, ")")) break;
+				//then it must be a comma
+				if (strcmp(token.string, ","))
+				{
+					SourceError(source, "define not terminated");
+					return qfalse;
+				} //end if
+			} //end while
+		} //end if
+		if (!PC_ReadLine(source, &token)) return qtrue;
+	} //end if
+	//read the defined stuff
+	last = NULL;
+	do
+	{
+		t = PC_CopyToken(&token);
+		if (t->type == TT_NAME && !strcmp(t->string, define->name))
+		{
+			SourceError(source, "recursive define (removed recursion)");
+			continue;
+		} //end if
+		PC_ClearTokenWhiteSpace(t);
+		t->next = NULL;
+		if (last) last->next = t;
+		else define->tokens = t;
+		last = t;
+	} while(PC_ReadLine(source, &token));
+	//
+	if (last)
+	{
+		//check for merge operators at the beginning or end
+		if (!strcmp(define->tokens->string, "##") ||
+				!strcmp(last->string, "##"))
+		{
+			SourceError(source, "define with misplaced ##");
+			return qfalse;
+		} //end if
+	} //end if
+	return qtrue;
+} //end of the function PC_Directive_define
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_DefineFromString(char *string)
+{
+	script_t *script;
+	source_t src;
+	token_t *t;
+	int res, i;
+	define_t *def;
+
+	PC_InitTokenHeap();
+
+	script = LoadScriptMemory(string, strlen(string), "*extern");
+	//create a new source
+	Com_Memset(&src, 0, sizeof(source_t));
+	strncpy(src.filename, "*extern", MAX_PATH);
+	src.scriptstack = script;
+#if DEFINEHASHING
+	src.definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	//create a define from the source
+	res = PC_Directive_define(&src);
+	//free any tokens if left
+	for (t = src.tokens; t; t = src.tokens)
+	{
+		src.tokens = src.tokens->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEFINEHASHING
+	def = NULL;
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		if (src.definehash[i])
+		{
+			def = src.definehash[i];
+			break;
+		} //end if
+	} //end for
+#else
+	def = src.defines;
+#endif //DEFINEHASHING
+	//
+#if DEFINEHASHING
+	FreeMemory(src.definehash);
+#endif //DEFINEHASHING
+	//
+	FreeScript(script);
+	//if the define was created succesfully
+	if (res > 0) return def;
+	//free the define is created
+	if (src.defines) PC_FreeDefine(def);
+	//
+	return NULL;
+} //end of the function PC_DefineFromString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_AddDefine(source_t *source, char *string)
+{
+	define_t *define;
+
+	define = PC_DefineFromString(string);
+	if (!define) return qfalse;
+#if DEFINEHASHING
+	PC_AddDefineToHash(define, source->definehash);
+#else //DEFINEHASHING
+	define->next = source->defines;
+	source->defines = define;
+#endif //DEFINEHASHING
+	return qtrue;
+} //end of the function PC_AddDefine
+//============================================================================
+// add a globals define that will be added to all opened sources
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_AddGlobalDefine(char *string)
+{
+	define_t *define;
+
+	define = PC_DefineFromString(string);
+	if (!define) return qfalse;
+	define->next = globaldefines;
+	globaldefines = define;
+	return qtrue;
+} //end of the function PC_AddGlobalDefine
+//============================================================================
+// remove the given global define
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_RemoveGlobalDefine(char *name)
+{
+	define_t *define;
+
+	define = PC_FindDefine(globaldefines, name);
+	if (define)
+	{
+		PC_FreeDefine(define);
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function PC_RemoveGlobalDefine
+//============================================================================
+// remove all globals defines
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_RemoveAllGlobalDefines(void)
+{
+	define_t *define;
+
+	for (define = globaldefines; define; define = globaldefines)
+	{
+		globaldefines = globaldefines->next;
+		PC_FreeDefine(define);
+	} //end for
+} //end of the function PC_RemoveAllGlobalDefines
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_CopyDefine(source_t *source, define_t *define)
+{
+	define_t *newdefine;
+	token_t *token, *newtoken, *lasttoken;
+
+	newdefine = (define_t *) GetMemory(sizeof(define_t) + strlen(define->name) + 1);
+	//copy the define name
+	newdefine->name = (char *) newdefine + sizeof(define_t);
+	strcpy(newdefine->name, define->name);
+	newdefine->flags = define->flags;
+	newdefine->builtin = define->builtin;
+	newdefine->numparms = define->numparms;
+	//the define is not linked
+	newdefine->next = NULL;
+	newdefine->hashnext = NULL;
+	//copy the define tokens
+	newdefine->tokens = NULL;
+	for (lasttoken = NULL, token = define->tokens; token; token = token->next)
+	{
+		newtoken = PC_CopyToken(token);
+		newtoken->next = NULL;
+		if (lasttoken) lasttoken->next = newtoken;
+		else newdefine->tokens = newtoken;
+		lasttoken = newtoken;
+	} //end for
+	//copy the define parameters
+	newdefine->parms = NULL;
+	for (lasttoken = NULL, token = define->parms; token; token = token->next)
+	{
+		newtoken = PC_CopyToken(token);
+		newtoken->next = NULL;
+		if (lasttoken) lasttoken->next = newtoken;
+		else newdefine->parms = newtoken;
+		lasttoken = newtoken;
+	} //end for
+	return newdefine;
+} //end of the function PC_CopyDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddGlobalDefinesToSource(source_t *source)
+{
+	define_t *define, *newdefine;
+
+	for (define = globaldefines; define; define = define->next)
+	{
+		newdefine = PC_CopyDefine(source, define);
+#if DEFINEHASHING
+		PC_AddDefineToHash(newdefine, source->definehash);
+#else //DEFINEHASHING
+		newdefine->next = source->defines;
+		source->defines = newdefine;
+#endif //DEFINEHASHING
+	} //end for
+} //end of the function PC_AddGlobalDefinesToSource
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_if_def(source_t *source, int type)
+{
+	token_t token;
+	define_t *d;
+	int skip;
+
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "#ifdef without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name after #ifdef, found %s", token.string);
+		return qfalse;
+	} //end if
+#if DEFINEHASHING
+	d = PC_FindHashedDefine(source->definehash, token.string);
+#else
+	d = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	skip = (type == INDENT_IFDEF) == (d == NULL);
+	PC_PushIndent(source, type, skip);
+	return qtrue;
+} //end of the function PC_Directiveif_def
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_ifdef(source_t *source)
+{
+	return PC_Directive_if_def(source, INDENT_IFDEF);
+} //end of the function PC_Directive_ifdef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_ifndef(source_t *source)
+{
+	return PC_Directive_if_def(source, INDENT_IFNDEF);
+} //end of the function PC_Directive_ifndef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_else(source_t *source)
+{
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type)
+	{
+		SourceError(source, "misplaced #else");
+		return qfalse;
+	} //end if
+	if (type == INDENT_ELSE)
+	{
+		SourceError(source, "#else after #else");
+		return qfalse;
+	} //end if
+	PC_PushIndent(source, INDENT_ELSE, !skip);
+	return qtrue;
+} //end of the function PC_Directive_else
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_endif(source_t *source)
+{
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type)
+	{
+		SourceError(source, "misplaced #endif");
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function PC_Directive_endif
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+typedef struct operator_s
+{
+	int operator;
+	int priority;
+	int parentheses;
+	struct operator_s *prev, *next;
+} operator_t;
+
+typedef struct value_s
+{
+	signed long int intvalue;
+	double floatvalue;
+	int parentheses;
+	struct value_s *prev, *next;
+} value_t;
+
+int PC_OperatorPriority(int op)
+{
+	switch(op)
+	{
+		case P_MUL: return 15;
+		case P_DIV: return 15;
+		case P_MOD: return 15;
+		case P_ADD: return 14;
+		case P_SUB: return 14;
+
+		case P_LOGIC_AND: return 7;
+		case P_LOGIC_OR: return 6;
+		case P_LOGIC_GEQ: return 12;
+		case P_LOGIC_LEQ: return 12;
+		case P_LOGIC_EQ: return 11;
+		case P_LOGIC_UNEQ: return 11;
+
+		case P_LOGIC_NOT: return 16;
+		case P_LOGIC_GREATER: return 12;
+		case P_LOGIC_LESS: return 12;
+
+		case P_RSHIFT: return 13;
+		case P_LSHIFT: return 13;
+
+		case P_BIN_AND: return 10;
+		case P_BIN_OR: return 8;
+		case P_BIN_XOR: return 9;
+		case P_BIN_NOT: return 16;
+
+		case P_COLON: return 5;
+		case P_QUESTIONMARK: return 5;
+	} //end switch
+	return qfalse;
+} //end of the function PC_OperatorPriority
+
+//#define AllocValue()			GetClearedMemory(sizeof(value_t));
+//#define FreeValue(val)		FreeMemory(val)
+//#define AllocOperator(op)		op = (operator_t *) GetClearedMemory(sizeof(operator_t));
+//#define FreeOperator(op)		FreeMemory(op);
+
+#define MAX_VALUES		64
+#define MAX_OPERATORS	64
+#define AllocValue(val)									\
+	if (numvalues >= MAX_VALUES) {						\
+		SourceError(source, "out of value space\n");		\
+		error = 1;										\
+		break;											\
+	}													\
+	else												\
+		val = &value_heap[numvalues++];
+#define FreeValue(val)
+//
+#define AllocOperator(op)								\
+	if (numoperators >= MAX_OPERATORS) {				\
+		SourceError(source, "out of operator space\n");	\
+		error = 1;										\
+		break;											\
+	}													\
+	else												\
+		op = &operator_heap[numoperators++];
+#define FreeOperator(op)
+
+int PC_EvaluateTokens(source_t *source, token_t *tokens, signed long int *intvalue,
+																	double *floatvalue, int integer)
+{
+	operator_t *o, *firstoperator, *lastoperator;
+	value_t *v, *firstvalue, *lastvalue, *v1, *v2;
+	token_t *t;
+	int brace = 0;
+	int parentheses = 0;
+	int error = 0;
+	int lastwasvalue = 0;
+	int negativevalue = 0;
+	int questmarkintvalue = 0;
+	double questmarkfloatvalue = 0;
+	int gotquestmarkvalue = qfalse;
+	int lastoperatortype = 0;
+	//
+	operator_t operator_heap[MAX_OPERATORS];
+	int numoperators = 0;
+	value_t value_heap[MAX_VALUES];
+	int numvalues = 0;
+
+	firstoperator = lastoperator = NULL;
+	firstvalue = lastvalue = NULL;
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	for (t = tokens; t; t = t->next)
+	{
+		switch(t->type)
+		{
+			case TT_NAME:
+			{
+				if (lastwasvalue || negativevalue)
+				{
+					SourceError(source, "syntax error in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (strcmp(t->string, "defined"))
+				{
+					SourceError(source, "undefined name %s in #if/#elif", t->string);
+					error = 1;
+					break;
+				} //end if
+				t = t->next;
+				if (!strcmp(t->string, "("))
+				{
+					brace = qtrue;
+					t = t->next;
+				} //end if
+				if (!t || t->type != TT_NAME)
+				{
+					SourceError(source, "defined without name in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				//v = (value_t *) GetClearedMemory(sizeof(value_t));
+				AllocValue(v);
+#if DEFINEHASHING
+				if (PC_FindHashedDefine(source->definehash, t->string))
+#else			
+				if (PC_FindDefine(source->defines, t->string))
+#endif //DEFINEHASHING
+				{
+					v->intvalue = 1;
+					v->floatvalue = 1;
+				} //end if
+				else
+				{
+					v->intvalue = 0;
+					v->floatvalue = 0;
+				} //end else
+				v->parentheses = parentheses;
+				v->next = NULL;
+				v->prev = lastvalue;
+				if (lastvalue) lastvalue->next = v;
+				else firstvalue = v;
+				lastvalue = v;
+				if (brace)
+				{
+					t = t->next;
+					if (!t || strcmp(t->string, ")"))
+					{
+						SourceError(source, "defined without ) in #if/#elif");
+						error = 1;
+						break;
+					} //end if
+				} //end if
+				brace = qfalse;
+				// defined() creates a value
+				lastwasvalue = 1;
+				break;
+			} //end case
+			case TT_NUMBER:
+			{
+				if (lastwasvalue)
+				{
+					SourceError(source, "syntax error in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				//v = (value_t *) GetClearedMemory(sizeof(value_t));
+				AllocValue(v);
+				if (negativevalue)
+				{
+					v->intvalue = - (signed int) t->intvalue;
+					v->floatvalue = - t->floatvalue;
+				} //end if
+				else
+				{
+					v->intvalue = t->intvalue;
+					v->floatvalue = t->floatvalue;
+				} //end else
+				v->parentheses = parentheses;
+				v->next = NULL;
+				v->prev = lastvalue;
+				if (lastvalue) lastvalue->next = v;
+				else firstvalue = v;
+				lastvalue = v;
+				//last token was a value
+				lastwasvalue = 1;
+				//
+				negativevalue = 0;
+				break;
+			} //end case
+			case TT_PUNCTUATION:
+			{
+				if (negativevalue)
+				{
+					SourceError(source, "misplaced minus sign in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (t->subtype == P_PARENTHESESOPEN)
+				{
+					parentheses++;
+					break;
+				} //end if
+				else if (t->subtype == P_PARENTHESESCLOSE)
+				{
+					parentheses--;
+					if (parentheses < 0)
+					{
+						SourceError(source, "too many ) in #if/#elsif");
+						error = 1;
+					} //end if
+					break;
+				} //end else if
+				//check for invalid operators on floating point values
+				if (!integer)
+				{
+					if (t->subtype == P_BIN_NOT || t->subtype == P_MOD ||
+						t->subtype == P_RSHIFT || t->subtype == P_LSHIFT ||
+						t->subtype == P_BIN_AND || t->subtype == P_BIN_OR ||
+						t->subtype == P_BIN_XOR)
+					{
+						SourceError(source, "illigal operator %s on floating point operands\n", t->string);
+						error = 1;
+						break;
+					} //end if
+				} //end if
+				switch(t->subtype)
+				{
+					case P_LOGIC_NOT:
+					case P_BIN_NOT:
+					{
+						if (lastwasvalue)
+						{
+							SourceError(source, "! or ~ after value in #if/#elif");
+							error = 1;
+							break;
+						} //end if
+						break;
+					} //end case
+					case P_INC:
+					case P_DEC:
+					{
+						SourceError(source, "++ or -- used in #if/#elif");
+						break;
+					} //end case
+					case P_SUB:
+					{
+						if (!lastwasvalue)
+						{
+							negativevalue = 1;
+							break;
+						} //end if
+					} //end case
+					
+					case P_MUL:
+					case P_DIV:
+					case P_MOD:
+					case P_ADD:
+
+					case P_LOGIC_AND:
+					case P_LOGIC_OR:
+					case P_LOGIC_GEQ:
+					case P_LOGIC_LEQ:
+					case P_LOGIC_EQ:
+					case P_LOGIC_UNEQ:
+
+					case P_LOGIC_GREATER:
+					case P_LOGIC_LESS:
+
+					case P_RSHIFT:
+					case P_LSHIFT:
+
+					case P_BIN_AND:
+					case P_BIN_OR:
+					case P_BIN_XOR:
+
+					case P_COLON:
+					case P_QUESTIONMARK:
+					{
+						if (!lastwasvalue)
+						{
+							SourceError(source, "operator %s after operator in #if/#elif", t->string);
+							error = 1;
+							break;
+						} //end if
+						break;
+					} //end case
+					default:
+					{
+						SourceError(source, "invalid operator %s in #if/#elif", t->string);
+						error = 1;
+						break;
+					} //end default
+				} //end switch
+				if (!error && !negativevalue)
+				{
+					//o = (operator_t *) GetClearedMemory(sizeof(operator_t));
+					AllocOperator(o);
+					o->operator = t->subtype;
+					o->priority = PC_OperatorPriority(t->subtype);
+					o->parentheses = parentheses;
+					o->next = NULL;
+					o->prev = lastoperator;
+					if (lastoperator) lastoperator->next = o;
+					else firstoperator = o;
+					lastoperator = o;
+					lastwasvalue = 0;
+				} //end if
+				break;
+			} //end case
+			default:
+			{
+				SourceError(source, "unknown %s in #if/#elif", t->string);
+				error = 1;
+				break;
+			} //end default
+		} //end switch
+		if (error) break;
+	} //end for
+	if (!error)
+	{
+		if (!lastwasvalue)
+		{
+			SourceError(source, "trailing operator in #if/#elif");
+			error = 1;
+		} //end if
+		else if (parentheses)
+		{
+			SourceError(source, "too many ( in #if/#elif");
+			error = 1;
+		} //end else if
+	} //end if
+	//
+	gotquestmarkvalue = qfalse;
+	questmarkintvalue = 0;
+	questmarkfloatvalue = 0;
+	//while there are operators
+	while(!error && firstoperator)
+	{
+		v = firstvalue;
+		for (o = firstoperator; o->next; o = o->next)
+		{
+			//if the current operator is nested deeper in parentheses
+			//than the next operator
+			if (o->parentheses > o->next->parentheses) break;
+			//if the current and next operator are nested equally deep in parentheses
+			if (o->parentheses == o->next->parentheses)
+			{
+				//if the priority of the current operator is equal or higher
+				//than the priority of the next operator
+				if (o->priority >= o->next->priority) break;
+			} //end if
+			//if the arity of the operator isn't equal to 1
+			if (o->operator != P_LOGIC_NOT
+					&& o->operator != P_BIN_NOT) v = v->next;
+			//if there's no value or no next value
+			if (!v)
+			{
+				SourceError(source, "mising values in #if/#elif");
+				error = 1;
+				break;
+			} //end if
+		} //end for
+		if (error) break;
+		v1 = v;
+		v2 = v->next;
+#ifdef DEBUG_EVAL
+		if (integer)
+		{
+			Log_Write("operator %s, value1 = %d", PunctuationFromNum(source->scriptstack, o->operator), v1->intvalue);
+			if (v2) Log_Write("value2 = %d", v2->intvalue);
+		} //end if
+		else
+		{
+			Log_Write("operator %s, value1 = %f", PunctuationFromNum(source->scriptstack, o->operator), v1->floatvalue);
+			if (v2) Log_Write("value2 = %f", v2->floatvalue);
+		} //end else
+#endif //DEBUG_EVAL
+		switch(o->operator)
+		{
+			case P_LOGIC_NOT:		v1->intvalue = !v1->intvalue;
+									v1->floatvalue = !v1->floatvalue; break;
+			case P_BIN_NOT:			v1->intvalue = ~v1->intvalue;
+									break;
+			case P_MUL:				v1->intvalue *= v2->intvalue;
+									v1->floatvalue *= v2->floatvalue; break;
+			case P_DIV:				if (!v2->intvalue || !v2->floatvalue)
+									{
+										SourceError(source, "divide by zero in #if/#elif\n");
+										error = 1;
+										break;
+									}
+									v1->intvalue /= v2->intvalue;
+									v1->floatvalue /= v2->floatvalue; break;
+			case P_MOD:				if (!v2->intvalue)
+									{
+										SourceError(source, "divide by zero in #if/#elif\n");
+										error = 1;
+										break;
+									}
+									v1->intvalue %= v2->intvalue; break;
+			case P_ADD:				v1->intvalue += v2->intvalue;
+									v1->floatvalue += v2->floatvalue; break;
+			case P_SUB:				v1->intvalue -= v2->intvalue;
+									v1->floatvalue -= v2->floatvalue; break;
+			case P_LOGIC_AND:		v1->intvalue = v1->intvalue && v2->intvalue;
+									v1->floatvalue = v1->floatvalue && v2->floatvalue; break;
+			case P_LOGIC_OR:		v1->intvalue = v1->intvalue || v2->intvalue;
+									v1->floatvalue = v1->floatvalue || v2->floatvalue; break;
+			case P_LOGIC_GEQ:		v1->intvalue = v1->intvalue >= v2->intvalue;
+									v1->floatvalue = v1->floatvalue >= v2->floatvalue; break;
+			case P_LOGIC_LEQ:		v1->intvalue = v1->intvalue <= v2->intvalue;
+									v1->floatvalue = v1->floatvalue <= v2->floatvalue; break;
+			case P_LOGIC_EQ:		v1->intvalue = v1->intvalue == v2->intvalue;
+									v1->floatvalue = v1->floatvalue == v2->floatvalue; break;
+			case P_LOGIC_UNEQ:		v1->intvalue = v1->intvalue != v2->intvalue;
+									v1->floatvalue = v1->floatvalue != v2->floatvalue; break;
+			case P_LOGIC_GREATER:	v1->intvalue = v1->intvalue > v2->intvalue;
+									v1->floatvalue = v1->floatvalue > v2->floatvalue; break;
+			case P_LOGIC_LESS:		v1->intvalue = v1->intvalue < v2->intvalue;
+									v1->floatvalue = v1->floatvalue < v2->floatvalue; break;
+			case P_RSHIFT:			v1->intvalue >>= v2->intvalue;
+									break;
+			case P_LSHIFT:			v1->intvalue <<= v2->intvalue;
+									break;
+			case P_BIN_AND:			v1->intvalue &= v2->intvalue;
+									break;
+			case P_BIN_OR:			v1->intvalue |= v2->intvalue;
+									break;
+			case P_BIN_XOR:			v1->intvalue ^= v2->intvalue;
+									break;
+			case P_COLON:
+			{
+				if (!gotquestmarkvalue)
+				{
+					SourceError(source, ": without ? in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (integer)
+				{
+					if (!questmarkintvalue) v1->intvalue = v2->intvalue;
+				} //end if
+				else
+				{
+					if (!questmarkfloatvalue) v1->floatvalue = v2->floatvalue;
+				} //end else
+				gotquestmarkvalue = qfalse;
+				break;
+			} //end case
+			case P_QUESTIONMARK:
+			{
+				if (gotquestmarkvalue)
+				{
+					SourceError(source, "? after ? in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				questmarkintvalue = v1->intvalue;
+				questmarkfloatvalue = v1->floatvalue;
+				gotquestmarkvalue = qtrue;
+				break;
+			} //end if
+		} //end switch
+#ifdef DEBUG_EVAL
+		if (integer) Log_Write("result value = %d", v1->intvalue);
+		else Log_Write("result value = %f", v1->floatvalue);
+#endif //DEBUG_EVAL
+		if (error) break;
+		lastoperatortype = o->operator;
+		//if not an operator with arity 1
+		if (o->operator != P_LOGIC_NOT
+				&& o->operator != P_BIN_NOT)
+		{
+			//remove the second value if not question mark operator
+			if (o->operator != P_QUESTIONMARK) v = v->next;
+			//
+			if (v->prev) v->prev->next = v->next;
+			else firstvalue = v->next;
+			if (v->next) v->next->prev = v->prev;
+			else lastvalue = v->prev;
+			//FreeMemory(v);
+			FreeValue(v);
+		} //end if
+		//remove the operator
+		if (o->prev) o->prev->next = o->next;
+		else firstoperator = o->next;
+		if (o->next) o->next->prev = o->prev;
+		else lastoperator = o->prev;
+		//FreeMemory(o);
+		FreeOperator(o);
+	} //end while
+	if (firstvalue)
+	{
+		if (intvalue) *intvalue = firstvalue->intvalue;
+		if (floatvalue) *floatvalue = firstvalue->floatvalue;
+	} //end if
+	for (o = firstoperator; o; o = lastoperator)
+	{
+		lastoperator = o->next;
+		//FreeMemory(o);
+		FreeOperator(o);
+	} //end for
+	for (v = firstvalue; v; v = lastvalue)
+	{
+		lastvalue = v->next;
+		//FreeMemory(v);
+		FreeValue(v);
+	} //end for
+	if (!error) return qtrue;
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	return qfalse;
+} //end of the function PC_EvaluateTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Evaluate(source_t *source, signed long int *intvalue,
+												double *floatvalue, int integer)
+{
+	token_t token, *firsttoken, *lasttoken;
+	token_t *t, *nexttoken;
+	define_t *define;
+	int defined = qfalse;
+
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "no value after #if/#elif");
+		return qfalse;
+	} //end if
+	firsttoken = NULL;
+	lasttoken = NULL;
+	do
+	{
+		//if the token is a name
+		if (token.type == TT_NAME)
+		{
+			if (defined)
+			{
+				defined = qfalse;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else if (!strcmp(token.string, "defined"))
+			{
+				defined = qtrue;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else
+			{
+				//then it must be a define
+#if DEFINEHASHING
+				define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+				define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+				if (!define)
+				{
+					SourceError(source, "can't evaluate %s, not defined", token.string);
+					return qfalse;
+				} //end if
+				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;
+			} //end else
+		} //end if
+		//if the token is a number or a punctuation
+		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)
+		{
+			t = PC_CopyToken(&token);
+			t->next = NULL;
+			if (lasttoken) lasttoken->next = t;
+			else firsttoken = t;
+			lasttoken = t;
+		} //end else
+		else //can't evaluate the token
+		{
+			SourceError(source, "can't evaluate %s", token.string);
+			return qfalse;
+		} //end else
+	} while(PC_ReadLine(source, &token));
+	//
+	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;
+	//
+#ifdef DEBUG_EVAL
+	Log_Write("eval:");
+#endif //DEBUG_EVAL
+	for (t = firsttoken; t; t = nexttoken)
+	{
+#ifdef DEBUG_EVAL
+		Log_Write(" %s", t->string);
+#endif //DEBUG_EVAL
+		nexttoken = t->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEBUG_EVAL
+	if (integer) Log_Write("eval result: %d", *intvalue);
+	else Log_Write("eval result: %f", *floatvalue);
+#endif //DEBUG_EVAL
+	//
+	return qtrue;
+} //end of the function PC_Evaluate
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarEvaluate(source_t *source, signed long int *intvalue,
+												double *floatvalue, int integer)
+{
+	int indent, defined = qfalse;
+	token_t token, *firsttoken, *lasttoken;
+	token_t *t, *nexttoken;
+	define_t *define;
+
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	//
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "no leading ( after $evalint/$evalfloat");
+		return qfalse;
+	} //end if
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "nothing to evaluate");
+		return qfalse;
+	} //end if
+	indent = 1;
+	firsttoken = NULL;
+	lasttoken = NULL;
+	do
+	{
+		//if the token is a name
+		if (token.type == TT_NAME)
+		{
+			if (defined)
+			{
+				defined = qfalse;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else if (!strcmp(token.string, "defined"))
+			{
+				defined = qtrue;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else
+			{
+				//then it must be a define
+#if DEFINEHASHING
+				define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+				define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+				if (!define)
+				{
+					SourceError(source, "can't evaluate %s, not defined", token.string);
+					return qfalse;
+				} //end if
+				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;
+			} //end else
+		} //end if
+		//if the token is a number or a punctuation
+		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)
+		{
+			if (*token.string == '(') indent++;
+			else if (*token.string == ')') indent--;
+			if (indent <= 0) break;
+			t = PC_CopyToken(&token);
+			t->next = NULL;
+			if (lasttoken) lasttoken->next = t;
+			else firsttoken = t;
+			lasttoken = t;
+		} //end else
+		else //can't evaluate the token
+		{
+			SourceError(source, "can't evaluate %s", token.string);
+			return qfalse;
+		} //end else
+	} while(PC_ReadSourceToken(source, &token));
+	//
+	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;
+	//
+#ifdef DEBUG_EVAL
+	Log_Write("$eval:");
+#endif //DEBUG_EVAL
+	for (t = firsttoken; t; t = nexttoken)
+	{
+#ifdef DEBUG_EVAL
+		Log_Write(" %s", t->string);
+#endif //DEBUG_EVAL
+		nexttoken = t->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEBUG_EVAL
+	if (integer) Log_Write("$eval result: %d", *intvalue);
+	else Log_Write("$eval result: %f", *floatvalue);
+#endif //DEBUG_EVAL
+	//
+	return qtrue;
+} //end of the function PC_DollarEvaluate
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_elif(source_t *source)
+{
+	signed long int value;
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type || type == INDENT_ELSE)
+	{
+		SourceError(source, "misplaced #elif");
+		return qfalse;
+	} //end if
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	skip = (value == 0);
+	PC_PushIndent(source, INDENT_ELIF, skip);
+	return qtrue;
+} //end of the function PC_Directive_elif
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_if(source_t *source)
+{
+	signed long int value;
+	int skip;
+
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	skip = (value == 0);
+	PC_PushIndent(source, INDENT_IF, skip);
+	return qtrue;
+} //end of the function PC_Directive
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_line(source_t *source)
+{
+	SourceError(source, "#line directive not supported");
+	return qfalse;
+} //end of the function PC_Directive_line
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_error(source_t *source)
+{
+	token_t token;
+
+	strcpy(token.string, "");
+	PC_ReadSourceToken(source, &token);
+	SourceError(source, "#error directive: %s", token.string);
+	return qfalse;
+} //end of the function PC_Directive_error
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_pragma(source_t *source)
+{
+	token_t token;
+
+	SourceWarning(source, "#pragma directive not supported");
+	while(PC_ReadLine(source, &token)) ;
+	return qtrue;
+} //end of the function PC_Directive_pragma
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void UnreadSignToken(source_t *source)
+{
+	token_t token;
+
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	strcpy(token.string, "-");
+	token.type = TT_PUNCTUATION;
+	token.subtype = P_SUB;
+	PC_UnreadSourceToken(source, &token);
+} //end of the function UnreadSignToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_eval(source_t *source)
+{
+	signed long int value;
+	token_t token;
+
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	//
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%d", abs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_Directive_eval
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_evalfloat(source_t *source)
+{
+	double value;
+	token_t token;
+
+	if (!PC_Evaluate(source, NULL, &value, qfalse)) return qfalse;
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%1.2f", fabs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_Directive_evalfloat
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+directive_t directives[20] =
+{
+	{"if", PC_Directive_if},
+	{"ifdef", PC_Directive_ifdef},
+	{"ifndef", PC_Directive_ifndef},
+	{"elif", PC_Directive_elif},
+	{"else", PC_Directive_else},
+	{"endif", PC_Directive_endif},
+	{"include", PC_Directive_include},
+	{"define", PC_Directive_define},
+	{"undef", PC_Directive_undef},
+	{"line", PC_Directive_line},
+	{"error", PC_Directive_error},
+	{"pragma", PC_Directive_pragma},
+	{"eval", PC_Directive_eval},
+	{"evalfloat", PC_Directive_evalfloat},
+	{NULL, NULL}
+};
+
+int PC_ReadDirective(source_t *source)
+{
+	token_t token;
+	int i;
+
+	//read the directive name
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "found # without name");
+		return qfalse;
+	} //end if
+	//directive name must be on the same line
+	if (token.linescrossed > 0)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "found # at end of line");
+		return qfalse;
+	} //end if
+	//if if is a name
+	if (token.type == TT_NAME)
+	{
+		//find the precompiler directive
+		for (i = 0; directives[i].name; i++)
+		{
+			if (!strcmp(directives[i].name, token.string))
+			{
+				return directives[i].func(source);
+			} //end if
+		} //end for
+	} //end if
+	SourceError(source, "unknown precompiler directive %s", token.string);
+	return qfalse;
+} //end of the function PC_ReadDirective
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarDirective_evalint(source_t *source)
+{
+	signed long int value;
+	token_t token;
+
+	if (!PC_DollarEvaluate(source, &value, NULL, qtrue)) return qfalse;
+	//
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%d", abs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;
+#ifdef NUMBERVALUE
+	token.intvalue = value;
+	token.floatvalue = value;
+#endif //NUMBERVALUE
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_DollarDirective_evalint
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarDirective_evalfloat(source_t *source)
+{
+	double value;
+	token_t token;
+
+	if (!PC_DollarEvaluate(source, NULL, &value, qfalse)) return qfalse;
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%1.2f", fabs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;
+#ifdef NUMBERVALUE
+	token.intvalue = (unsigned long) value;
+	token.floatvalue = value;
+#endif //NUMBERVALUE
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_DollarDirective_evalfloat
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+directive_t dollardirectives[20] =
+{
+	{"evalint", PC_DollarDirective_evalint},
+	{"evalfloat", PC_DollarDirective_evalfloat},
+	{NULL, NULL}
+};
+
+int PC_ReadDollarDirective(source_t *source)
+{
+	token_t token;
+	int i;
+
+	//read the directive name
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "found $ without name");
+		return qfalse;
+	} //end if
+	//directive name must be on the same line
+	if (token.linescrossed > 0)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "found $ at end of line");
+		return qfalse;
+	} //end if
+	//if if is a name
+	if (token.type == TT_NAME)
+	{
+		//find the precompiler directive
+		for (i = 0; dollardirectives[i].name; i++)
+		{
+			if (!strcmp(dollardirectives[i].name, token.string))
+			{
+				return dollardirectives[i].func(source);
+			} //end if
+		} //end for
+	} //end if
+	PC_UnreadSourceToken(source, &token);
+	SourceError(source, "unknown precompiler directive %s", token.string);
+	return qfalse;
+} //end of the function PC_ReadDirective
+
+#ifdef QUAKEC
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int BuiltinFunction(source_t *source)
+{
+	token_t token;
+
+	if (!PC_ReadSourceToken(source, &token)) return qfalse;
+	if (token.type == TT_NUMBER)
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qtrue;
+	} //end if
+	else
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qfalse;
+	} //end else
+} //end of the function BuiltinFunction
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int QuakeCMacro(source_t *source)
+{
+	int i;
+	token_t token;
+
+	if (!PC_ReadSourceToken(source, &token)) return qtrue;
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qtrue;
+	} //end if
+	//find the precompiler directive
+	for (i = 0; dollardirectives[i].name; i++)
+	{
+		if (!strcmp(dollardirectives[i].name, token.string))
+		{
+			PC_UnreadSourceToken(source, &token);
+			return qfalse;
+		} //end if
+	} //end for
+	PC_UnreadSourceToken(source, &token);
+	return qtrue;
+} //end of the function QuakeCMacro
+#endif //QUAKEC
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadToken(source_t *source, token_t *token)
+{
+	define_t *define;
+
+	while(1)
+	{
+		if (!PC_ReadSourceToken(source, token)) return qfalse;
+		//check for precompiler directives
+		if (token->type == TT_PUNCTUATION && *token->string == '#')
+		{
+#ifdef QUAKEC
+			if (!BuiltinFunction(source))
+#endif //QUAKC
+			{
+				//read the precompiler directive
+				if (!PC_ReadDirective(source)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		if (token->type == TT_PUNCTUATION && *token->string == '$')
+		{
+#ifdef QUAKEC
+			if (!QuakeCMacro(source))
+#endif //QUAKEC
+			{
+				//read the precompiler directive
+				if (!PC_ReadDollarDirective(source)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		// recursively concatenate strings that are behind each other still resolving defines
+		if (token->type == TT_STRING)
+		{
+			token_t newtoken;
+			if (PC_ReadToken(source, &newtoken))
+			{
+				if (newtoken.type == TT_STRING)
+				{
+					token->string[strlen(token->string)-1] = '\0';
+					if (strlen(token->string) + strlen(newtoken.string+1) + 1 >= MAX_TOKEN)
+					{
+						SourceError(source, "string longer than MAX_TOKEN %d\n", MAX_TOKEN);
+						return qfalse;
+					}
+					strcat(token->string, newtoken.string+1);
+				}
+				else
+				{
+					PC_UnreadToken(source, &newtoken);
+				}
+			}
+		} //end if
+		//if skipping source because of conditional compilation
+		if (source->skip) continue;
+		//if the token is a name
+		if (token->type == TT_NAME)
+		{
+			//check if the name is a define macro
+#if DEFINEHASHING
+			define = PC_FindHashedDefine(source->definehash, token->string);
+#else
+			define = PC_FindDefine(source->defines, token->string);
+#endif //DEFINEHASHING
+			//if it is a define macro
+			if (define)
+			{
+				//expand the defined macro
+				if (!PC_ExpandDefineIntoSource(source, token, define)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		//copy token for unreading
+		Com_Memcpy(&source->token, token, sizeof(token_t));
+		//found a token
+		return qtrue;
+	} //end while
+} //end of the function PC_ReadToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectTokenString(source_t *source, char *string)
+{
+	token_t token;
+
+	if (!PC_ReadToken(source, &token))
+	{
+		SourceError(source, "couldn't find expected %s", string);
+		return qfalse;
+	} //end if
+
+	if (strcmp(token.string, string))
+	{
+		SourceError(source, "expected %s, found %s", string, token.string);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function PC_ExpectTokenString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectTokenType(source_t *source, int type, int subtype, token_t *token)
+{
+	char str[MAX_TOKEN];
+
+	if (!PC_ReadToken(source, token))
+	{
+		SourceError(source, "couldn't read expected token");
+		return qfalse;
+	} //end if
+
+	if (token->type != type)
+	{
+		strcpy(str, "");
+		if (type == TT_STRING) strcpy(str, "string");
+		if (type == TT_LITERAL) strcpy(str, "literal");
+		if (type == TT_NUMBER) strcpy(str, "number");
+		if (type == TT_NAME) strcpy(str, "name");
+		if (type == TT_PUNCTUATION) strcpy(str, "punctuation");
+		SourceError(source, "expected a %s, found %s", str, token->string);
+		return qfalse;
+	} //end if
+	if (token->type == TT_NUMBER)
+	{
+		if ((token->subtype & subtype) != subtype)
+		{
+			if (subtype & TT_DECIMAL) strcpy(str, "decimal");
+			if (subtype & TT_HEX) strcpy(str, "hex");
+			if (subtype & TT_OCTAL) strcpy(str, "octal");
+			if (subtype & TT_BINARY) strcpy(str, "binary");
+			if (subtype & TT_LONG) strcat(str, " long");
+			if (subtype & TT_UNSIGNED) strcat(str, " unsigned");
+			if (subtype & TT_FLOAT) strcat(str, " float");
+			if (subtype & TT_INTEGER) strcat(str, " integer");
+			SourceError(source, "expected %s, found %s", str, token->string);
+			return qfalse;
+		} //end if
+	} //end if
+	else if (token->type == TT_PUNCTUATION)
+	{
+		if (token->subtype != subtype)
+		{
+			SourceError(source, "found %s", token->string);
+			return qfalse;
+		} //end if
+	} //end else if
+	return qtrue;
+} //end of the function PC_ExpectTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectAnyToken(source_t *source, token_t *token)
+{
+	if (!PC_ReadToken(source, token))
+	{
+		SourceError(source, "couldn't read expected token");
+		return qfalse;
+	} //end if
+	else
+	{
+		return qtrue;
+	} //end else
+} //end of the function PC_ExpectAnyToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_CheckTokenString(source_t *source, char *string)
+{
+	token_t tok;
+
+	if (!PC_ReadToken(source, &tok)) return qfalse;
+	//if the token is available
+	if (!strcmp(tok.string, string)) return qtrue;
+	//
+	PC_UnreadSourceToken(source, &tok);
+	return qfalse;
+} //end of the function PC_CheckTokenString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_CheckTokenType(source_t *source, int type, int subtype, token_t *token)
+{
+	token_t tok;
+
+	if (!PC_ReadToken(source, &tok)) return qfalse;
+	//if the type matches
+	if (tok.type == type &&
+			(tok.subtype & subtype) == subtype)
+	{
+		Com_Memcpy(token, &tok, sizeof(token_t));
+		return qtrue;
+	} //end if
+	//
+	PC_UnreadSourceToken(source, &tok);
+	return qfalse;
+} //end of the function PC_CheckTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_SkipUntilString(source_t *source, char *string)
+{
+	token_t token;
+
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, string)) return qtrue;
+	} //end while
+	return qfalse;
+} //end of the function PC_SkipUntilString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_UnreadLastToken(source_t *source)
+{
+	PC_UnreadSourceToken(source, &source->token);
+} //end of the function PC_UnreadLastToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_UnreadToken(source_t *source, token_t *token)
+{
+	PC_UnreadSourceToken(source, token);
+} //end of the function PC_UnreadToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_SetIncludePath(source_t *source, char *path)
+{
+	strncpy(source->includepath, path, MAX_PATH);
+	//add trailing path seperator
+	if (source->includepath[strlen(source->includepath)-1] != '\\' &&
+		source->includepath[strlen(source->includepath)-1] != '/')
+	{
+		strcat(source->includepath, PATHSEPERATOR_STR);
+	} //end if
+} //end of the function PC_SetIncludePath
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_SetPunctuations(source_t *source, punctuation_t *p)
+{
+	source->punctuations = p;
+} //end of the function PC_SetPunctuations
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+source_t *LoadSourceFile(const char *filename)
+{
+	source_t *source;
+	script_t *script;
+
+	PC_InitTokenHeap();
+
+	script = LoadScriptFile(filename);
+	if (!script) return NULL;
+
+	script->next = NULL;
+
+	source = (source_t *) GetMemory(sizeof(source_t));
+	Com_Memset(source, 0, sizeof(source_t));
+
+	strncpy(source->filename, filename, MAX_PATH);
+	source->scriptstack = script;
+	source->tokens = NULL;
+	source->defines = NULL;
+	source->indentstack = NULL;
+	source->skip = 0;
+
+#if DEFINEHASHING
+	source->definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	PC_AddGlobalDefinesToSource(source);
+	return source;
+} //end of the function LoadSourceFile
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+source_t *LoadSourceMemory(char *ptr, int length, char *name)
+{
+	source_t *source;
+	script_t *script;
+
+	PC_InitTokenHeap();
+
+	script = LoadScriptMemory(ptr, length, name);
+	if (!script) return NULL;
+	script->next = NULL;
+
+	source = (source_t *) GetMemory(sizeof(source_t));
+	Com_Memset(source, 0, sizeof(source_t));
+
+	strncpy(source->filename, name, MAX_PATH);
+	source->scriptstack = script;
+	source->tokens = NULL;
+	source->defines = NULL;
+	source->indentstack = NULL;
+	source->skip = 0;
+
+#if DEFINEHASHING
+	source->definehash = GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	PC_AddGlobalDefinesToSource(source);
+	return source;
+} //end of the function LoadSourceMemory
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void FreeSource(source_t *source)
+{
+	script_t *script;
+	token_t *token;
+	define_t *define;
+	indent_t *indent;
+	int i;
+
+	//PC_PrintDefineHashTable(source->definehash);
+	//free all the scripts
+	while(source->scriptstack)
+	{
+		script = source->scriptstack;
+		source->scriptstack = source->scriptstack->next;
+		FreeScript(script);
+	} //end for
+	//free all the tokens
+	while(source->tokens)
+	{
+		token = source->tokens;
+		source->tokens = source->tokens->next;
+		PC_FreeToken(token);
+	} //end for
+#if DEFINEHASHING
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		while(source->definehash[i])
+		{
+			define = source->definehash[i];
+			source->definehash[i] = source->definehash[i]->hashnext;
+			PC_FreeDefine(define);
+		} //end while
+	} //end for
+#else //DEFINEHASHING
+	//free all defines
+	while(source->defines)
+	{
+		define = source->defines;
+		source->defines = source->defines->next;
+		PC_FreeDefine(define);
+	} //end for
+#endif //DEFINEHASHING
+	//free all indents
+	while(source->indentstack)
+	{
+		indent = source->indentstack;
+		source->indentstack = source->indentstack->next;
+		FreeMemory(indent);
+	} //end for
+#if DEFINEHASHING
+	//
+	if (source->definehash) FreeMemory(source->definehash);
+#endif //DEFINEHASHING
+	//free the source itself
+	FreeMemory(source);
+} //end of the function FreeSource
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+
+#define MAX_SOURCEFILES		64
+
+source_t *sourceFiles[MAX_SOURCEFILES];
+
+int PC_LoadSourceHandle(const char *filename)
+{
+	source_t *source;
+	int i;
+
+	for (i = 1; i < MAX_SOURCEFILES; i++)
+	{
+		if (!sourceFiles[i])
+			break;
+	} //end for
+	if (i >= MAX_SOURCEFILES)
+		return 0;
+	PS_SetBaseFolder("");
+	source = LoadSourceFile(filename);
+	if (!source)
+		return 0;
+	sourceFiles[i] = source;
+	return i;
+} //end of the function PC_LoadSourceHandle
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_FreeSourceHandle(int handle)
+{
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return qfalse;
+	if (!sourceFiles[handle])
+		return qfalse;
+
+	FreeSource(sourceFiles[handle]);
+	sourceFiles[handle] = NULL;
+	return qtrue;
+} //end of the function PC_FreeSourceHandle
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadTokenHandle(int handle, pc_token_t *pc_token)
+{
+	token_t token;
+	int ret;
+
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return 0;
+	if (!sourceFiles[handle])
+		return 0;
+
+	ret = PC_ReadToken(sourceFiles[handle], &token);
+	strcpy(pc_token->string, token.string);
+	pc_token->type = token.type;
+	pc_token->subtype = token.subtype;
+	pc_token->intvalue = token.intvalue;
+	pc_token->floatvalue = token.floatvalue;
+	if (pc_token->type == TT_STRING)
+		StripDoubleQuotes(pc_token->string);
+	return ret;
+} //end of the function PC_ReadTokenHandle
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_SourceFileAndLine(int handle, char *filename, int *line)
+{
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return qfalse;
+	if (!sourceFiles[handle])
+		return qfalse;
+
+	strcpy(filename, sourceFiles[handle]->filename);
+	if (sourceFiles[handle]->scriptstack)
+		*line = sourceFiles[handle]->scriptstack->line;
+	else
+		*line = 0;
+	return qtrue;
+} //end of the function PC_SourceFileAndLine
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_SetBaseFolder(char *path)
+{
+	PS_SetBaseFolder(path);
+} //end of the function PC_SetBaseFolder
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_CheckOpenSourceHandles(void)
+{
+	int i;
+
+	for (i = 1; i < MAX_SOURCEFILES; i++)
+	{
+		if (sourceFiles[i])
+		{
+#ifdef BOTLIB
+			botimport.Print(PRT_ERROR, "file %s still open in precompiler\n", sourceFiles[i]->scriptstack->filename);
+#endif	//BOTLIB
+		} //end if
+	} //end for
+} //end of the function PC_CheckOpenSourceHandles
+