Quake-III-Arena

l_precomp.c (88624B)

---

 /*
 ===========================================================================
 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