fteqw/engine/qclib/qcc_pr_lex.c

#if !defined(MINIMAL) && !defined(OMIT_QCC)

#include "qcc.h"
#include "time.h"

#define MEMBERFIELDNAME "__m%s"

#define STRCMP(s1,s2) (((*s1)!=(*s2)) || strcmp(s1,s2))	//saves about 2-6 out of 120 - expansion of idea from fastqcc

void QCC_PR_PreProcessor_Define(pbool append);
pbool QCC_PR_UndefineName(const char *name);
const char *QCC_PR_CheckCompConstString(const char *def);
CompilerConstant_t *QCC_PR_CheckCompConstDefined(const char *def);
int QCC_PR_CheckCompConst(void);
pbool QCC_Include(const char *filename);
void QCC_FreeDef(QCC_def_t *def);
void QCC_PR_LexComment(char **comment);

extern pbool	destfile_explicit;
extern char		destfile[1024];
//static const QCC_sref_t nullsref = {0};

#define MAXINCLUDEDIRS 8
char	qccincludedir[MAXINCLUDEDIRS][256];	//the -src path, for #includes
struct qccincludeonced_s
{
	struct qccincludeonced_s *next;
	char name[1];
} *qccincludeonced;	//the -src path, for #includes

char *compilingfile;

int			pr_source_line;

char		*pr_file_p;
char		*pr_line_start;		// start of current source line

int			pr_bracelevel;

char		*pr_token_precomment;
char		pr_token[8192];
token_type_t	pr_token_type;
int				pr_token_line;
int				pr_token_line_last;
QCC_type_t		*pr_immediate_type;
QCC_eval_t		pr_immediate;

char	pr_immediate_string[8192];
size_t	pr_immediate_strlen;

int		pr_error_count;
int		pr_warning_count;

extern pbool expandedemptymacro;

//really these should not be in here
extern unsigned int locals_end, locals_start;
extern QCC_type_t *pr_classtype;
QCC_function_t *QCC_PR_ParseImmediateStatements (QCC_def_t *def, QCC_type_t *type, pbool dowrap);
QCC_type_t *QCC_PR_FieldType (QCC_type_t *pointsto);

static void Q_strlcpy(char *dest, const char *src, int sizeofdest)
{
	if (sizeofdest)
	{
		int slen = strlen(src);
		slen = min((sizeofdest-1), slen);
		memcpy(dest, src, slen);
		dest[slen] = 0;
	}
}



char	*pr_punctuation[] =
// longer symbols must be before a shorter partial match
{"&&", "||", "<=>", "<=", ">=","==", "!=", "/=", "*=", "+=", "-=", "(+)", "(-)", "|=", "&~=", "&=", "++", "--", "->", "^=", "::", ";", ",", "!", "*^", "*", "/", "(", ")", "-", "+", "=", "[", "]", "{", "}", "...", "..", ".", "><", "<<=", "<<", "<", ">>=", ">>", ">" , "?", "#" , "@", "&" , "|", "%", "^^", "^", "~", ":", NULL};

char *pr_punctuationremap[] =	//a nice bit of evilness.
//(+) -> |=
//-> -> .
//(-) -> &~=
{"&&", "||", "<=>", "<=", ">=","==", "!=", "/=", "*=", "+=", "-=", "|=",  "&~=", "|=", "&~=", "&=", "++", "--", ".",  "^=", "::", ";", ",", "!", "*^", "*", "/", "(", ")", "-", "+", "=", "[", "]", "{", "}", "...", "..", ".", "><", "<<=", "<<", "<", ">>=", ">>", ">" , "?", "#" , "@", "&" , "|", "%", "^^", "^", "~", ":", NULL};

// simple types.  function types are dynamically allocated
QCC_type_t	*type_void;				//void
QCC_type_t	*type_string;			//string
QCC_type_t	*type_float;			//float
QCC_type_t	*type_double;			//double
QCC_type_t	*type_vector;			//vector
QCC_type_t	*type_entity;			//entity
QCC_type_t	*type_field;			//.void
QCC_type_t	*type_function;			//void()
QCC_type_t	*type_floatfunction;	//float()
QCC_type_t	*type_pointer;			//??? * - careful with this one
QCC_type_t	*type_integer;			//int32
QCC_type_t	*type_uint;				//uint32
QCC_type_t	*type_int64;				//int64
QCC_type_t	*type_uint64;			//uint64
QCC_type_t	*type_variant;			//__variant
QCC_type_t	*type_floatpointer;		//float *
QCC_type_t	*type_intpointer;		//int *
QCC_type_t	*type_bint;				//int (0 or 1)
QCC_type_t	*type_bfloat;			//float (0.0 or 1.0, and never -0.0)

QCC_type_t	*type_floatfield;// = {ev_field/*, &def_field*/, NULL, &type_float};

QCC_def_t	def_ret, def_parms[MAX_PARMS];

//QCC_def_t	*def_for_type[9] = {&def_void, &def_string, &def_float, &def_vector, &def_entity, &def_field, &def_function, &def_pointer, &def_integer};

void QCC_PR_LexWhitespace (pbool inhibitpreprocessor);


QCC_type_t *QCC_PR_ParseEnum(pbool flags);

//for compiler constants and file includes.

qcc_includechunk_t *currentchunk;
void QCC_PR_CloseProcessor(void)
{
	int i;
	for (i = 0; i < MAXINCLUDEDIRS; i++)
		*qccincludedir[i] = 0;
	currentchunk = NULL;
	qccincludeonced = NULL;
}
void QCC_PR_AddIncludePath(const char *newinc)
{
	int i;

	if (!*newinc)
	{
		newinc = ".";
//		QCC_PR_ParseWarning(WARN_STRINGTOOLONG, "Invalid include path.");
//		return;
	}

	for (i = 0; i < MAXINCLUDEDIRS; i++)
	{
		if (!*qccincludedir[i])
		{
			pbool trunc;
			const char *e = newinc + strlen(newinc)-1;
			trunc = !QC_strlcpy(qccincludedir[i], newinc, sizeof(qccincludedir));
			if (*e != '/' && *e != '\\')
				trunc |= !QC_strlcat(qccincludedir[i], "/", sizeof(qccincludedir));
			if (trunc)
			{
				QCC_PR_ParseWarning(WARN_STRINGTOOLONG, "Include path too long.");
				*qccincludedir[i] = 0;
			}
			break;
		}
		if (!strcmp(qccincludedir[i], newinc))
			break;
	}
	if (i == MAXINCLUDEDIRS)
	{
		QCC_PR_ParseWarning(WARN_STRINGTOOLONG, "Too many include dirs. Ignoring and hoping the stars align.");
	}
}
static void QCC_PR_IncludeChunkEx (char *data, pbool duplicate, char *filename, CompilerConstant_t *cnst)
{
	qcc_includechunk_t *chunk = qccHunkAlloc(sizeof(qcc_includechunk_t));
	chunk->prev = currentchunk;
	currentchunk = chunk;

	chunk->currentdatapoint = pr_file_p;
	chunk->currentfilename = s_filen;
	chunk->currentlinenumber = pr_source_line;
	chunk->cnst = cnst;
	if( cnst )
	{
#if 0
		s_filen = cnst->fromfile;
		pr_source_line = cnst->fromline;
#else
		int b = strlen(s_filen)+1+8+strlen(cnst->name);
		char *p;
		if (b > 128)
			b = 128;
		s_filen = p = qccHunkAlloc(b);
		QC_snprintfz(p, b, "%s:%i:%s", chunk->currentfilename, chunk->currentlinenumber, cnst->name);
		pr_source_line = 1;
#endif
		cnst->inside++;
	}
	else
		pr_source_line = 1;

	if (duplicate)
	{
		pr_file_p = qccHunkAlloc(strlen(data)+1);
		strcpy(pr_file_p, data);
	}
	else
		pr_file_p = data;
	chunk->datastart = pr_file_p;
}
void QCC_PR_IncludeChunk (char *data, pbool duplicate, char *filename)
{
	QCC_PR_IncludeChunkEx(data, duplicate, filename, NULL);
}

pbool QCC_PR_UnInclude(void)
{
	if (!currentchunk)
		return false;

	if( currentchunk->cnst )
		currentchunk->cnst->inside--;

	pr_file_p = currentchunk->currentdatapoint;
	pr_source_line = currentchunk->currentlinenumber;
	s_filen = currentchunk->currentfilename;

	currentchunk = currentchunk->prev;

	return true;
}

//expresses a relative path relative to an existing FILEname. any directories in base must be / terminated properly.
void QCC_JoinPaths(char *fullname, size_t fullnamesize, const char *newfile, const char *base)
{
	char *end;

	if (*newfile == '/' || *newfile == '\\')
	{	//its an absolute path...
		QC_strlcpy(fullname, newfile, fullnamesize);
		return;
	}
	QC_strlcpy(fullname, base, fullnamesize);
	end = fullname+strlen(fullname);
	while (end > fullname)
	{
		end--;
		if (*end == '/' || *end == '\\')
		{
			end++;
			break;
		}
	}
	QC_strlcpy(end, newfile, fullnamesize - (end-fullname));

	//FIXME: do we want to convert /segment/../ into just / ?
	//fteqw might insist on it for its filesystem sandboxing.
	//but it breaks symlink weirdness (itself a possible security hole).
	//should probably be a separate function.
}

extern char qccmsourcedir[];
//also meant to include it.
void QCC_FindBestInclude(char *newfile, char *currentfile, pbool verbose)
{
	struct qccincludeonced_s *onced;
	int includepath = 0;
	char fullname[1024];

	if (!*newfile)
		return;

	while(1)
	{
		if (includepath)
		{
			if (includepath > MAXINCLUDEDIRS || !*qccincludedir[includepath-1])
				QCC_Error(ERR_COULDNTOPENFILE, "Couldn't open file %s", newfile);

			currentfile = qccincludedir[includepath-1];
		}

		QCC_JoinPaths(fullname, sizeof(fullname), newfile, currentfile);

		{
			extern progfuncs_t *qccprogfuncs;
			if (qccprogfuncs->funcs.parms->FileSize(fullname) == -1)
			{
				includepath++;
				continue;
			}
		}
		break;
	}

	for(onced = qccincludeonced; onced; onced = onced->next)
	{
		if (!strcmp(onced->name, fullname))
			return;
	}

	if (verbose)
	{
		if (verbose == 2)
		{
			if (autoprototype)
				externs->Printf("prototyping %s\n", fullname);
			else
				externs->Printf("compiling %s\n", fullname);
		}
		else
		{
			if (autoprototype)
				externs->Printf("prototyping include %s\n", fullname);
			else
				externs->Printf("including %s\n", fullname);
		}
	}
	QCC_Include(fullname);
}

pbool defaultnoref;
pbool defaultnosave;
pbool defaultstatic;
int ForcedCRC;
float qcc_framerate;

int QCC_PR_LexInteger (void);
void	QCC_AddFile (char *filename);
void QCC_PR_LexString (void);
pbool QCC_PR_SimpleGetToken (void);
pbool QCC_PR_SimpleGetString(void);

#define PPI_VALUE 0
#define PPI_NOT 1
#define PPI_DEFINED 2
#define PPI_COMPARISON 3
#define PPI_LOGICAL 4
#define PPI_TOPLEVEL 5
static int ParsePrecompilerIf(int level)
{
	CompilerConstant_t *c;
	int eval = 0;
//	pbool notted = false;

	//single term end-of-chain
	if (level == PPI_VALUE)
	{
		/*skip whitespace*/
		while (*pr_file_p && qcc_iswhite(*pr_file_p) && *pr_file_p != '\n')
		{
			pr_file_p++;
		}

		if (*pr_file_p == '(')
		{	//try brackets
			pr_file_p++;
			eval = ParsePrecompilerIf(PPI_TOPLEVEL);
			while (*pr_file_p == ' ' || *pr_file_p == '\t')
				pr_file_p++;
			if (*pr_file_p != ')')
				QCC_PR_ParseError(ERR_EXPECTED, "unclosed bracket condition\n");
			pr_file_p++;
		}
		else if (*pr_file_p == '!')
		{	//try brackets
			pr_file_p++;
			eval = !ParsePrecompilerIf(PPI_NOT);
		}
		else
		{	//simple token...
			if (!strncmp(pr_file_p, "defined", 7))
			{
				pr_file_p+=7;
				while (*pr_file_p == ' ' || *pr_file_p == '\t')
					pr_file_p++;
				if (*pr_file_p != '(')
				{
					eval = false;
					QCC_PR_ParseError(ERR_EXPECTED, "no opening bracket after defined\n");
				}
				else
				{
					pr_file_p++;

					QCC_PR_SimpleGetToken();
					eval = !!QCC_PR_CheckCompConstDefined(pr_token);

					while (*pr_file_p == ' ' || *pr_file_p == '\t')
						pr_file_p++;
					if (*pr_file_p != ')')
						QCC_PR_ParseError(ERR_EXPECTED, "unclosed defined condition\n");
					pr_file_p++;
				}
			}
			else
			{
				if (!QCC_PR_SimpleGetToken())
					QCC_PR_ParseError(ERR_EXPECTED, "unexpected end-of-line\n");
				c = QCC_PR_CheckCompConstDefined(pr_token);
				if (!c)
					eval = atoi(pr_token);
				else
					eval = atoi(c->value);
			}
		}
		return eval;
	}

	eval = ParsePrecompilerIf(level-1);

	while (*pr_file_p && qcc_iswhite(*pr_file_p) && *pr_file_p != '\n')
	{
		pr_file_p++;
	}

	switch(level)
	{
	case PPI_LOGICAL:
		if (!strncmp(pr_file_p, "||", 2))
		{
			pr_file_p+=2;
			eval = ParsePrecompilerIf(level)||eval;
		}
		else if (!strncmp(pr_file_p, "&&", 2))
		{
			pr_file_p+=2;
			eval = ParsePrecompilerIf(level)&&eval;
		}
		break;
	case PPI_COMPARISON:
		if (!strncmp(pr_file_p, "<=", 2))
		{
			pr_file_p+=2;
			eval = eval <= ParsePrecompilerIf(level);
		}
		else if (!strncmp(pr_file_p, ">=", 2))
		{
			pr_file_p += 2;
			eval = eval >= ParsePrecompilerIf(level);
		}
		else if (!strncmp(pr_file_p, "<", 1))
		{
			pr_file_p += 1;
			eval = eval < ParsePrecompilerIf(level);
		}
		else if (!strncmp(pr_file_p, ">", 1))
		{
			pr_file_p += 1;
			eval = eval > ParsePrecompilerIf(level);
		}
		else if (!strncmp(pr_file_p, "!=", 2))
		{
			pr_file_p += 2;
			eval = eval != ParsePrecompilerIf(level);
		}
		else if (!strncmp(pr_file_p, "==", 2))
		{
			pr_file_p += 2;
			eval = eval == ParsePrecompilerIf(level);
		}
		break;
	}
	return eval;
}

struct deflist_s
{
	char *buffer;
	size_t length;
	size_t buffersize;
};
static void QCC_PR_GetDefinesListEnumerate(void *vctx, void *data)
{
	struct deflist_s *ctx = vctx;
	CompilerConstant_t *def = data;
	char term[8192];
	size_t termsize;
	pbool success = true;

	QC_snprintfz(term, sizeof(term), "\n%s", def->name);
	if (def->numparams >= 0)
	{
		int i;
		success &= QC_strlcat(term, "(", sizeof(term));
		for (i = 0; i < def->numparams; i++)
		{
			if (i)
				success &= QC_strlcat(term, ",", sizeof(term));
			success &= QC_strlcat(term, def->params[i], sizeof(term));
		}
		success &= QC_strlcat(term, ")", sizeof(term));
	}
	if (def->value && *def->value)
	{
		char *o, *i;
		success &= QC_strlcat(term, "=", sizeof(term));

		//annoying logic to skip whitespace... hopefully it won't fuck stuff up too much.
		for (o = term+strlen(term), i = def->value; o < term + sizeof(term)-1 && *i; )
		{
			if (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r')
				i++;
			else
				*o++ = *i++;
		}
		*o = 0;
	}
	if (!success)	//this define was too long. don't show truncated stuff.
		return;

	termsize = strlen(term);
	if (ctx->length + termsize+1 > ctx->buffersize)
	{
		ctx->buffersize = (ctx->length + termsize+1)*2;
		ctx->buffer = realloc(ctx->buffer, ctx->buffersize);
	}
	memcpy(ctx->buffer+ctx->length, term, termsize);
	ctx->length += termsize;
	ctx->buffer[ctx->length] = 0;
}
char *QCC_PR_GetDefinesList(void)
{
	struct deflist_s ctx = {NULL};
	Hash_Enumerate(&compconstantstable, QCC_PR_GetDefinesListEnumerate, &ctx);
	return ctx.buffer;
}

//returns true if it was white/comments only. false if there was actual text that was skipped.
static void QCC_PR_SkipToEndOfLine(pbool errorifnonwhite)
{
	pbool handleccomments = true;
	while(*pr_file_p != '\n' && *pr_file_p != '\0')	//read on until the end of the line
	{
		if (*pr_file_p == '/' && pr_file_p[1] == '*' && handleccomments)
		{
			pr_file_p += 2;
			while(*pr_file_p)
			{
				if (*pr_file_p == '*' && pr_file_p[1] == '/')
				{
					pr_file_p+=2;
					break;
				}
				if (*pr_file_p == '\n')
					pr_source_line++;
				pr_file_p++;
			}
		}
		else if (*pr_file_p == '/' && pr_file_p[1] == '/' && handleccomments)
		{
			handleccomments = false;
			pr_file_p += 2;
			/*while(*pr_file_p)
			{
				if (*pr_file_p == '\n')
					break;
				pr_file_p++;
			}*/
		}
		else if (*pr_file_p == '\\' && pr_file_p[1] == '\r' && pr_file_p[2] == '\n')
		{	/*windows endings*/
			pr_file_p+=3;
			pr_source_line++;
		}
		else if (*pr_file_p == '\"' && handleccomments)
		{
			if (errorifnonwhite)
			{
				errorifnonwhite = false;
				QCC_PR_ParseWarning (ERR_UNKNOWNPUCTUATION, "unexpected tokens at end of line");
			}
			pr_file_p++;
			while (*pr_file_p)
			{
				if (*pr_file_p == '\n')
					break;	//this text is junk/ignored, so ignore the obvious error here.
				else if (*pr_file_p == '\"')
				{
					pr_file_p++;
					break;
				}
				else if (*pr_file_p == '\\' && pr_file_p[1] == '\"')
					pr_file_p+=2;	//don't trip on "\"/*"
				else if (*pr_file_p == '\\' && pr_file_p[1] == '\\')
					pr_file_p+=2;	//don't trip on "\\"//"foo
				else
					pr_file_p++;
				//any other \ should be part of the actual string, which we don't care about here
			}
		}
		else if (*pr_file_p == '\\' && pr_file_p[1] == '\n')
		{	/*linux endings*/
			pr_file_p+=2;

			pr_source_line++;
		}
		else
		{
			if (errorifnonwhite && handleccomments && !qcc_iswhite(*pr_file_p))
			{
				errorifnonwhite = false;
				QCC_PR_ParseWarning(ERR_UNKNOWNPUCTUATION, "unexpected tokens at end of line");
			}

			pr_file_p++;
		}
	}
}

//if hadtrue, then we allow elses, otherwise we skip them.
static pbool QCC_PR_FalsePreProcessorIf(pbool hadtrue, int originalline)
{
	int eval;
	int level = 1;
	while (1)
	{
		while(*pr_file_p && (*pr_file_p==' ' || *pr_file_p == '\t'))
			pr_file_p++;

		if (!*pr_file_p)
		{
			pr_source_line = originalline;
			QCC_PR_ParseError (ERR_NOENDIF, "#if with no endif");
		}

		if (*pr_file_p == '#')
		{
			pr_file_p++;
			while(*pr_file_p==' ' || *pr_file_p == '\t')
				pr_file_p++;
			if (!strncmp(pr_file_p, "endif", 5))
				level--;
			if (!strncmp(pr_file_p, "if", 2))
				level++;
			if (!hadtrue && !strncmp(pr_file_p, "else", 4) && level == 1)
			{
				pr_file_p+=4;
				QCC_PR_SkipToEndOfLine(true);
				return true;
			}
			if (!hadtrue && !strncmp(pr_file_p, "elif", 4) && level == 1)
			{
//				QCC_PR_ParseError(ERR_UNKNOWNPUCTUATION, "#elif not supported\n");

				pr_file_p += 4;
				if (!strncmp(pr_file_p, "def", 3))
				{
					eval = 1;
					pr_file_p += 3;
				}
				else if (!strncmp(pr_file_p, "ndef", 4))
				{
					eval = 0;
					pr_file_p += 4;
				}
				else
					eval = 2;
				if (*pr_file_p != ' ' && *pr_file_p != '\t')
					QCC_PR_ParseError(ERR_UNKNOWNPUCTUATION, "malformed #elif\n");
				if (eval == 2)
					eval = ParsePrecompilerIf(PPI_TOPLEVEL);
				else
				{
					QCC_PR_SimpleGetToken ();
					if (eval)
						eval = !!QCC_PR_CheckCompConstDefined(pr_token);
					else
						eval = !QCC_PR_CheckCompConstDefined(pr_token);
				}
				if (eval)
				{
					QCC_PR_SkipToEndOfLine(true);
					return true;
				}
			}
		}

		QCC_PR_SkipToEndOfLine(false);

		if (level <= 0)
			return false;
		pr_file_p++;	//next line
		pr_source_line++;
	}
}

#if 0
static void QCC_PR_PackagerMessage(void *userctx, char *message, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,message);
	QC_vsnprintf (string,sizeof(string)-1,message,argptr);
	va_end (argptr);

	externs->Printf ("%s", string);
}
#endif

/*
==============
QCC_PR_Precompiler
==============

Runs precompiler stage
*/
static pbool QCC_PR_Precompiler(void)
{
	char msg[1024];
	int ifmode;
	int a;
	static int ifs = 0;
	pbool eval = false;

	if (*pr_file_p == '#')
	{
		char *directive;
		for (directive = pr_file_p+1; *directive; directive++)	//so #    define works
		{
			if (*directive == '\r' || *directive == '\n')
				QCC_PR_ParseError(ERR_UNKNOWNPUCTUATION, "Hanging # with no directive\n");
			if (*directive > ' ')
				break;
		}
		if (!strncmp(directive, "define", 6))
		{
			pr_file_p = directive;
			QCC_PR_PreProcessor_Define(false);
			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "append", 6))
		{
			pr_file_p = directive;
			QCC_PR_PreProcessor_Define(true);
			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "undef", 5))
		{
			pr_file_p = directive+5;
			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			QCC_PR_SimpleGetToken ();
			QCC_PR_UndefineName(pr_token);

	//		QCC_PR_ConditionCompilation();
			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "if", 2))
		{
			int originalline = pr_source_line;
 			pr_file_p = directive+2;
			if (!strncmp(pr_file_p, "def", 3))
			{
				ifmode = 0;
				pr_file_p+=3;
			}
			else if (!strncmp(pr_file_p, "ndef", 4))
			{
				ifmode = 1;
				pr_file_p+=4;
			}
			else
			{
				ifmode = 2;
				pr_file_p+=0;
				//QCC_PR_ParseError("bad \"#if\" type");
			}

			if (!qcc_iswhite(*pr_file_p))
			{
				pr_file_p = directive;
				QCC_PR_SimpleGetToken ();
				QCC_PR_ParseWarning(WARN_BADPRAGMA, "Unknown pragma \'%s\'", qcc_token);
			}
			else
			{
				if (ifmode == 2)
				{
					eval = ParsePrecompilerIf(PPI_TOPLEVEL);
				}
				else
				{
					QCC_PR_SimpleGetToken ();

		//			if (!STRCMP(pr_token, "COOP_MODE"))
		//				eval = false;
					if (QCC_PR_CheckCompConstDefined(pr_token))
						eval = true;

					if (ifmode == 1)
						eval = eval?false:true;
				}

				QCC_PR_SkipToEndOfLine(true);

				if (eval)
					ifs+=1;
				else
					ifs += QCC_PR_FalsePreProcessorIf(false, originalline);
			}
		}
		else if (!strncmp(directive, "else", 4) || !strncmp(directive, "elif", 4))
		{
			int originalline = pr_source_line;

			if (!ifs)
				QCC_PR_ParseError(ERR_UNKNOWNPUCTUATION, "#else outside of #if\n");

			ifs -= 1;

			pr_file_p = directive+4;
			if (!strncmp(directive, "elif", 4))
				QCC_PR_SkipToEndOfLine(false);
			else
				QCC_PR_SkipToEndOfLine(true);

			ifs += QCC_PR_FalsePreProcessorIf(true, originalline);
		}
		else if (!strncmp(directive, "endif", 5))
		{
			pr_file_p = directive+5;
			QCC_PR_SkipToEndOfLine(true);
			if (ifs <= 0)
				QCC_PR_ParseError(ERR_NOPRECOMPILERIF, "unmatched #endif");
			else
				ifs-=1;
		}
		else if (!strncmp(directive, "eof", 3))
		{
			pr_file_p = NULL;
			return true;
		}
		else if (!strncmp(directive, "error", 5))
		{
			pr_file_p = directive+5;
			for (a = 0; a < sizeof(msg)-1 && pr_file_p[a] != '\t' && pr_file_p[a] != '\n' && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];
			msg[a] = '\0';

			QCC_PR_SkipToEndOfLine(false);

			QCC_PR_ParseError(ERR_HASHERROR, "#Error: %s", msg);
		}
		else if (!strncmp(directive, "warning", 7))
		{
			pr_file_p = directive+7;
			for (a = 0; a < 1023 && pr_file_p[a] != '\r' && pr_file_p[a] != '\n' && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];
			msg[a] = '\0';

			QCC_PR_SkipToEndOfLine(false);

			QCC_PR_ParseWarning(WARN_PRECOMPILERMESSAGE, "#warning: %s", msg);
		}
		else if (!strncmp(directive, "message", 7))
		{
			pr_file_p = directive+7;
			for (a = 0; a < sizeof(msg)-1 && pr_file_p[a] != '\r' && pr_file_p[a] != '\n' && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];
			msg[a] = '\0';

			if (flag_msvcstyle)
				externs->Printf ("%s(%i) : #message: %s\n", s_filen, pr_source_line, msg);
			else
				externs->Printf ("%s:%i: #message: %s\n", s_filen, pr_source_line, msg);
			QCC_PR_SkipToEndOfLine(false);
		}
		else if (!strncmp(directive, "copyright", 9))
		{
			pr_file_p = directive+9;
			for (a = 0; a < sizeof(msg)-1 && qcc_iswhite(pr_file_p[a]) && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];
			msg[a] = '\0';

			QCC_PR_SkipToEndOfLine(false);

			if (strlen(msg) >= sizeof(QCC_copyright))
				QCC_PR_ParseWarning(WARN_STRINGTOOLONG, "Copyright message is too long\n");
			QC_strlcpy(QCC_copyright, msg, sizeof(QCC_copyright)-1);
		}
		else if (!strncmp(directive, "package", 7))
		{
			pr_file_p=directive+7;

			QCC_PR_SkipToEndOfLine(true);

#if 0
			if (!autoprototype)
			{
				struct pkgctx_s *ctx = Packager_Create(QCC_PR_PackagerMessage, NULL);
				Packager_ParseText(ctx, pr_file_p);
				Packager_WriteDataset(ctx, NULL);
				Packager_Destroy(ctx);
			}
#endif

			pr_file_p += strlen(pr_file_p);
		}
		else if (!strncmp(directive, "pack", 4))
		{
			ifmode = 0;
			pr_file_p=directive+4;
			if (!strncmp(pr_file_p, "id", 2))
				pr_file_p+=3;
			else
			{
				ifmode = QCC_PR_LexInteger();
				if (ifmode == 0)
					ifmode = 1;
				pr_file_p++;
			}
			for (a = 0; a < sizeof(msg)-1 && qcc_iswhite(pr_file_p[a]) && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];
			msg[a] = '\0';

			QCC_PR_SkipToEndOfLine(true);

			if (ifmode == 0)
				QCC_packid = atoi(msg);
			else if (ifmode <= 5)
				strcpy(QCC_Packname[ifmode-1], msg);
			else
				QCC_PR_ParseError(ERR_TOOMANYPACKFILES, "No more than 5 packs are allowed");
		}
		else if (!strncmp(directive, "forcecrc", 8))
		{
			pr_file_p=directive+8;

			ForcedCRC = QCC_PR_LexInteger();

			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "merge", 5))
		{
			pr_file_p=directive+5;

			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			QCC_PR_SimpleGetString();
			externs->Printf("Merging from %s\n", pr_token);
			QCC_ImportProgs(pr_token);
			if (!*destfile && !destfile_explicit)
			{
				QCC_JoinPaths(destfile, sizeof(destfile), pr_token, compilingfile);
				externs->Printf("Outputfile: %s\n", destfile);
			}

			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "includelist", 11))
		{
			int defines=0;
			pr_file_p=directive+11;

			QCC_PR_SkipToEndOfLine(true);

			while(1)
			{
				QCC_PR_LexWhitespace(false);
				if (!flag_hashonly && QCC_PR_CheckCompConst())
				{
					defines++;
					continue;
				}
				if (!QCC_PR_SimpleGetToken())
				{
					if (!*pr_file_p)
					{
						if (defines>0)
						{
							defines--;
							QCC_PR_UnInclude();
							continue;
						}
						QCC_Error(ERR_EOF, "eof in includelist");
					}
					else
					{
						pr_file_p++;
						pr_source_line++;
					}
					continue;
				}
				if (!strcmp(pr_token, "#endlist"))
				{
					QCC_PR_SkipToEndOfLine(true);
					break;
				}

				QCC_FindBestInclude(pr_token, compilingfile, true);

				if (*pr_file_p == '\r')
					pr_file_p++;

//				QCC_PR_SkipToEndOfLine(true);
			}
		}
		else if (!strncmp(directive, "include", 7))
		{
			char sm;

			pr_file_p=directive+7;

			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			msg[0] = '\0';
			if (*pr_file_p == '\"')
				sm = '\"';
			else if (*pr_file_p == '<')
				sm = '>';
			else
			{
				QCC_PR_ParseError(0, "Not a string literal (on a #include)");
				sm = 0;
			}
			pr_file_p++;
			a=0;
			while(*pr_file_p != sm)
			{
				if (*pr_file_p == '\n')
				{
					QCC_PR_ParseError(0, "#include continued over line boundry\n");
					break;
				}
				msg[a++] = *pr_file_p;
				pr_file_p++;
			}
			msg[a] = 0;
			pr_file_p++;

			QCC_FindBestInclude(msg, compilingfile, false);

			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "datafile", 8))
		{
			pr_file_p=directive+8;

			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			QCC_PR_SimpleGetString();
			externs->Printf("Including datafile: %s\n", pr_token);
			QCC_AddFile(pr_token);

			pr_file_p++;

			for (a = 0; a < sizeof(msg)-1 && pr_file_p[a] != '\n' && pr_file_p[a] != '\0'; a++)
				msg[a] = pr_file_p[a];

			msg[a-1] = '\0';

			while(*pr_file_p != '\n' && *pr_file_p != '\0')	//read on until the end of the line
			{
				pr_file_p++;
			}
		}
		else if (!strncmp(directive, "output", 6))
		{
			pr_file_p=directive+6;

			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			QCC_PR_SimpleGetString();
			if (!destfile_explicit)
			{
				QCC_JoinPaths(destfile, sizeof(destfile), pr_token, compilingfile);
				externs->Printf("Outputfile: %s\n", pr_token);
			}

			QCC_PR_SkipToEndOfLine(true);
		}
		else if (!strncmp(directive, "pragma", 6))
		{
			pr_file_p=directive+6;
			while(qcc_iswhitesameline(*pr_file_p))
				pr_file_p++;

			qcc_token[0] = '\0';
			for(a = 0; *pr_file_p != '\n' && *pr_file_p != '\0'; pr_file_p++)	//read on until the end of the line
			{
				if ((*pr_file_p == ' ' || *pr_file_p == '\t'|| *pr_file_p == '(') && !*qcc_token)
				{
					msg[a] = '\0';
					strcpy(qcc_token, msg);
					a=0;
					if (*pr_file_p != '(')
						continue;
				}
				msg[a++] = *pr_file_p;
			}

			msg[a] = '\0';
			{
				char *end;
				for (end = msg + a-1; end>=msg && qcc_iswhite(*end); end--)
					*end = '\0';
			}

			if (!*qcc_token)
			{
				strcpy(qcc_token, msg);
				msg[0] = '\0';
			}

			{
				char *end;
				for (end = msg + a-1; end>=msg && qcc_iswhite(*end); end--)
					*end = '\0';
			}

			if (!QC_strcasecmp(qcc_token, "DONT_COMPILE_THIS_FILE"))
			{
				QCC_PR_LexWhitespace(false);
				while (*pr_file_p)
				{
					if (!qcc_iswhite(*pr_file_p))
						pr_file_p++;
					QCC_PR_LexWhitespace(false);
				}
			}
			else if (!QC_strcasecmp(qcc_token, "COPYRIGHT"))
			{
				char *e = strrchr(msg+1, '\"');
				if (*msg == '\"' && e && e != msg)
				{	//FIXME: handle \ns
					memmove(msg, msg+1, e-(msg+1));
					msg[e-(msg+1)] = 0;
				}
				if (!QC_strlcpy(QCC_copyright, msg, sizeof(QCC_copyright)))
					QCC_PR_ParseWarning(WARN_STRINGTOOLONG, "Copyright message is too long\n");
			}
			else if (!QC_strcasecmp(qcc_token, "compress"))
			{
				extern pbool compressoutput;
				compressoutput = atoi(msg);
			}
			else if (!QC_strcasecmp(qcc_token, "forcecrc"))
			{
				ForcedCRC = atoi(msg);
			}
			else if (!QC_strcasecmp(qcc_token, "framerate"))
			{
				qcc_framerate = atof(msg);
			}
			else if (!QC_strcasecmp(qcc_token, "once"))
			{
				struct qccincludeonced_s *onced = qccHunkAlloc(sizeof(*onced) + strlen(compilingfile));
				strcpy(onced->name, compilingfile);
				onced->next = qccincludeonced;
				qccincludeonced = onced;
			}
			else if (!QC_strcasecmp(qcc_token, "file"))
			{	//#pragma file(foobar.qc)
				if (!flag_nopragmafileline)
				{
					char *e;
					char *m = msg;
					if (*m == '(')
					{
						m++;
						e = strchr(m, ')');
						if (e)
							*e = 0;
					}

					s_filen = e = qccHunkAlloc(strlen(m)+1);
					strcpy(e, m);
					if (opt_filenames)
					{
						optres_filenames += strlen(m);
						s_filed = 0;
					}
					else
						s_filed = QCC_CopyString (m);
				}
			}
			else if (!QC_strcasecmp(qcc_token, "line"))
			{	//#pragma line(666)
				if (!flag_nopragmafileline)
				{
					char *m = msg;
					if (*m == '(')
						m++;
					pr_source_line = strtoul(m, &m, 0)-1;
				}
			}
			else if (!QC_strcasecmp(qcc_token, "includedir"))
			{
				char newinc[1024];
				int i;
				QCC_COM_Parse(msg);

				if (*qcc_token)
				{
					 i = qcc_token[strlen(qcc_token)-1];
					 if (i != '/' && i != '\\')
						 QC_strlcat(qcc_token, "/", sizeof(qcc_token));
				}

				QCC_JoinPaths(newinc, sizeof(newinc), qcc_token, compilingfile);
				QCC_PR_AddIncludePath(newinc);
			}
			else if (!QC_strcasecmp(qcc_token, "noref"))
				defaultnoref = !!atoi(msg);
			else if (!QC_strcasecmp(qcc_token, "nosave"))
				defaultnosave = !!atoi(msg);
			else if (!QC_strcasecmp(qcc_token, "defaultstatic"))
				defaultstatic = !!atoi(msg);
			else if (!QC_strcasecmp(qcc_token, "autoproto"))
			{
				if (!autoprototyped)
				{
					if (numpr_globals != RESERVED_OFS)
						QCC_PR_ParseWarning(WARN_BADPRAGMA, "#pragma autoproto must appear before any definitions");
					else
						autoprototype = *msg?!!atoi(msg):true;
				}
			}
			else if (!QC_strcasecmp(qcc_token, "wrasm"))
			{
				pbool on = atoi(msg);

				if (asmfile && !on)
				{
					fclose(asmfile);
					asmfile = NULL;
				}
				if (!asmfile && on)
				{
					if (asmfilebegun)
						asmfile = fopen("qc.asm", "ab");
					else
						asmfile = fopen("qc.asm", "wb");
					if (asmfile)
						asmfilebegun = true;
				}
			}
			else if (!QC_strcasecmp(qcc_token, "optimise") || !QC_strcasecmp(qcc_token, "optimize"))	//bloomin' americans.
			{
				int o;
				extern pbool qcc_nopragmaoptimise;
				if (pr_scope)
					QCC_PR_ParseWarning(WARN_BADPRAGMA, "pragma %s: unable to change optimisation options mid-function", qcc_token);
				else if (*msg >= '0' && *msg <= '3')
				{
					int lev = atoi(msg);
					pbool state;
					int once = false;
					for (o = 0; optimisations[o].enabled; o++)
					{
						state = optimisations[o].optimisationlevel <= lev;
						if (qcc_nopragmaoptimise && *optimisations[o].enabled != state)
						{
							if (!once++)
								QCC_PR_ParseWarning(WARN_BADPRAGMA, "pragma %s %s: overriden by commandline", qcc_token, msg);
						}
						else
							*optimisations[o].enabled = state;
					}
				}
				else if (!strnicmp(msg, "addon", 5) || !strnicmp(msg, "mutator", 7))
				{
					int lev = 2;
					pbool state = false;
					for (o = 0; optimisations[o].enabled; o++)
					{
						if (optimisations[o].optimisationlevel > lev)
						{
							if (qcc_nopragmaoptimise && *optimisations[o].enabled != state)
								QCC_PR_ParseWarning(WARN_IGNORECOMMANDLINE, "pragma %s %s: disabling %s", qcc_token, msg, optimisations[o].fullname);
							*optimisations[o].enabled = state;
						}
					}
				}
				else
				{
					char *opt = msg;
					pbool state = true;
					if (!strnicmp(msg, "no-", 3))
					{
						state = false;
						opt += 3;
					}
					for (o = 0; optimisations[o].enabled; o++)
						if ((*optimisations[o].abbrev && !stricmp(opt, optimisations[o].abbrev)) || !stricmp(opt, optimisations[o].fullname))
						{
							if (qcc_nopragmaoptimise && *optimisations[o].enabled != state)
								QCC_PR_ParseWarning(WARN_BADPRAGMA, "pragma %s %s: overriden by commandline", qcc_token, optimisations[o].fullname);
							else
								*optimisations[o].enabled = state;
							break;
						}
					if (!optimisations[o].enabled)
						QCC_PR_ParseWarning(WARN_BADPRAGMA, "pragma %s: %s unsupported", qcc_token, opt);
				}
			}
			else if (!QC_strcasecmp(qcc_token, "sourcefile"))
			{
				char *s = msg;
				while ((s = QCC_COM_Parse(s)))
					QCC_RegisterSourceFile(qcc_token);
			}
			else if (!QC_strcasecmp(qcc_token, "TARGET"))
			{
				QCC_COM_Parse(msg);
				if (!QCC_OPCodeSetTargetName(qcc_token))
					QCC_PR_ParseWarning(WARN_BADTARGET, "Unknown target \'%s\'. Ignored.\nValid targets are: ID, HEXEN2, FTE, FTEH2, KK7, DP(patched)", qcc_token);
			}
			else if (!QC_strcasecmp(qcc_token, "PROGS_SRC"))
			{	//doesn't make sense, but silenced if you are switching between using a certain precompiler app used with CuTF.
			}
			else if (!QC_strcasecmp(qcc_token, "PROGS_DAT"))
			{	//doesn't make sence, but silenced if you are switching between using a certain precompiler app used with CuTF.
				char olddest[1024];
				Q_strlcpy(olddest, destfile, sizeof(olddest));
				QCC_COM_Parse(msg);

				if (!destfile_explicit) //if output file is named on the commandline, don't change it mid-compile
					QCC_JoinPaths(destfile, sizeof(destfile), qcc_token, compilingfile);

				if (strcmp(destfile, olddest))
					externs->Printf("Outputfile: %s\n", destfile);
			}
			else if (!QC_strcasecmp(qcc_token, "opcode"))
			{
				int st;
				char *s = QCC_COM_Parse(msg);
				if (!QC_strcasecmp(qcc_token, "enable") || !QC_strcasecmp(qcc_token, "on"))
					st = 1;
				else if (!QC_strcasecmp(qcc_token, "disable") || !QC_strcasecmp(qcc_token, "off"))
					st = 0;
				else
				{
					QCC_PR_ParseWarning(WARN_BADPRAGMA, "opcode state not recognised");
					st = -1;
				}

				if (st >= 0)
				{
					int f;
					while ((s = QCC_COM_Parse(s)))
					{
						for (f = 0; pr_opcodes[f].opname; f++)
						{
							if (!QC_strcasecmp(pr_opcodes[f].opname, qcc_token))
							{
								if (st)
									pr_opcodes[f].flags |= OPF_VALID;
								else
									pr_opcodes[f].flags &= ~OPF_VALID;
								break;
							}
						}
						if (!pr_opcodes[f].opname)
							QCC_PR_ParseWarning(WARN_BADPRAGMA, "opcode %s not recognised", qcc_token);
					}
				}
			}
			else if (!QC_strcasecmp(qcc_token, "keyword") || !QC_strcasecmp(qcc_token, "flag"))
			{
				char *s;
				int st;
				s = QCC_COM_Parse(msg);
				if (!QC_strcasecmp(qcc_token, "enable") || !QC_strcasecmp(qcc_token, "on"))
					st = 1;
				else if (!QC_strcasecmp(qcc_token, "disable") || !QC_strcasecmp(qcc_token, "off"))
					st = 0;
				else
				{
					QCC_PR_ParseWarning(WARN_BADPRAGMA, "compiler flag state not recognised");
					st = -1;
				}
				if (st >= 0)
				{
					int f;
					while ((s = QCC_COM_Parse(s)))
					{
						for (f = 0; compiler_flag[f].enabled; f++)
						{
							if (!QC_strcasecmp(compiler_flag[f].abbrev, qcc_token))
							{
								if (compiler_flag[f].flags & FLAG_MIDCOMPILE)
								{
									*compiler_flag[f].enabled = st;
									if (compiler_flag[f].enabled == &flag_cpriority)
										QCC_PrioritiseOpcodes();
								}
								else
									QCC_PR_ParseWarning(WARN_BADPRAGMA, "Cannot enable/disable keyword/flag via a pragma");
								break;
							}
						}
						if (!compiler_flag[f].enabled)
							QCC_PR_ParseWarning(WARN_BADPRAGMA, "keyword/flag %s not recognised", qcc_token);
					}
				}
			}
			else if (!QC_strcasecmp(qcc_token, "warning"))
			{
				int st;
				char *s;
				s = QCC_COM_Parse(msg);
				if (!stricmp(qcc_token, "enable") || !stricmp(qcc_token, "on"))
					st = WA_WARN;
				else if (!stricmp(qcc_token, "disable") || !stricmp(qcc_token, "off") || !stricmp(qcc_token, "ignore"))
					st = WA_IGNORE;
				else if (!stricmp(qcc_token, "error"))
					st = WA_ERROR;
				else if (!stricmp(qcc_token, "toggle"))
					st = 3;
				else
				{
					QCC_PR_ParseWarning(WARN_BADPRAGMA, "warning state not recognised");
					st = -1;
				}
				if (st>=0)
				{
					int wn;
					while ((s = QCC_COM_Parse(s)))
					{
						wn = QCC_WarningForName(qcc_token);
						if (wn < 0)
							QCC_PR_ParseWarning(WARN_BADPRAGMA, "warning id not recognised");
						else
						{
							if (st == 3)	//toggle
								qccwarningaction[wn] = !!qccwarningaction[wn];
							else
								qccwarningaction[wn] = st;
						}
					}
				}
			}
			else
			{
				QCC_PR_SkipToEndOfLine(false);
				QCC_PR_ParseWarning(WARN_BADPRAGMA, "Unknown pragma \'%s\'", qcc_token);
			}

			QCC_PR_SkipToEndOfLine(true);
		}
		return true;
	}

	return false;
}

/*
==============
PR_NewLine

Call at start of file and when *pr_file_p == '\n'
==============
*/
void QCC_PR_NewLine (pbool incomment)
{
	pr_source_line++;
	pr_line_start = pr_file_p;
	while(*pr_file_p==' ' || *pr_file_p == '\t')
		pr_file_p++;
	if (incomment)	//no constants if in a comment.
	{
	}
	else if (QCC_PR_Precompiler())
	{
	}

//	if (pr_dumpasm)
//		PR_PrintNextLine ();
}

/*
==============
PR_LexString

Parses a quoted string
==============
*/
int QCC_PR_LexEscapedCodepoint(void)
{	//for "\foo" or '\foo' handling.
	//caller will have read the \ already.
	int t;
	int c = *pr_file_p++;
	if (!c)
		QCC_PR_ParseError (ERR_EOF, "EOF inside quote");
	if (c == 'n')
		c = '\n';
	else if (c == 'r')
		c = '\r';
	else if (c == '#')	//avoid preqcc expansion in strings.
		c = '#';
	else if (c == '"')
		c = '"';
	else if (c == 't')
		c = '\t';	//tab
	else if (c == 'a')
		c = '\a';	//bell
	else if (c == 'v')
		c = '\v';	//vertical tab
	else if (c == 'f')
		c = '\f';	//form feed
//	else if (c == 's' || c == 'b')
//		c = 0;	//invalid...
	//else if (c == 'b')
	//	c = '\b';
	else if (c == '[')
		c = 0xe010;	//quake specific
	else if (c == ']')
		c = 0xe011;	//quake specific
	else if (c == '{')
	{
		int d;
		c = 0;
		if (*pr_file_p == 'x')
		{
			pr_file_p++;
			while ((d = *pr_file_p++) != '}')
			{
				if (d >= '0' && d <= '9')
					c = c * 16 + d - '0';
				else if (d >= 'a' && d <= 'f')
					c = c * 16 + 10+d - 'a';
				else if (d >= 'A' && d <= 'F')
					c = c * 16 + 10+d - 'A';
				else
					QCC_PR_ParseError(ERR_BADCHARACTERCODE, "Bad character code");
			}
		}
		else
		{
			while ((d = *pr_file_p++) != '}')
			{
				if (d >= '0' && d <= '9')
					c = c * 10 + d - '0';
				else
					QCC_PR_ParseError(ERR_BADCHARACTERCODE, "Bad character code");
			}
		}
	}
	else if (c == '.')
		c = 0xe01c;
	else if (c == '<')
		c = 0xe01d;	//separator start
	else if (c == '-')
		c = 0xe01e;	//separator middle
	else if (c == '>')
		c = 0xe01f;	//separator end
	else if (c == '(')
		c = 0xe080;	//slider start
	else if (c == '=')
		c = 0xe081;	//slider middle
	else if (c == ')')
		c = 0xe082;	//slider end
	else if (c == '+')
		c = 0xe083;	//slider box
	else if (c == 'u' || c == 'U')
	{
		//lower case u specifies exactly 4 nibbles.
		//upper case U specifies exactly 8 nibbles.
		unsigned int nibbles = (c=='u')?4:8;
		c = 0;
		while (nibbles --> 0)
		{
			t = (unsigned char)*pr_file_p;
			if (t >= '0' && t <= '9')
				c = (c*16) + (t - '0');
			else if (t >= 'A' && t <= 'F')
				c = (c*16) + (t - 'A') + 10;
			else if (t >= 'a' && t <= 'f')
				c = (c*16) + (t - 'a') + 10;
			else
				break;
			pr_file_p++;
		}
		if (nibbles)
			QCC_PR_ParseWarning(ERR_BADCHARACTERCODE, "Unicode character terminated unexpectedly");
	}
	else if (c == 'x' || c == 'X')
	{
		int d;
		c = 0;

		d = (unsigned char)*pr_file_p++;
		if (d >= '0' && d <= '9')
			c += d - '0';
		else if (d >= 'A' && d <= 'F')
			c += d - 'A' + 10;
		else if (d >= 'a' && d <= 'f')
			c += d - 'a' + 10;
		else
			QCC_PR_ParseError(ERR_BADCHARACTERCODE, "Bad character code");

		c *= 16;

		d = (unsigned char)*pr_file_p++;
		if (d >= '0' && d <= '9')
			c += d - '0';
		else if (d >= 'A' && d <= 'F')
			c += d - 'A' + 10;
		else if (d >= 'a' && d <= 'f')
			c += d - 'a' + 10;
		else
			QCC_PR_ParseError(ERR_BADCHARACTERCODE, "Bad character code");
	}
	else if (c == '\\')
		c = '\\';
	else if (c == '\'')
		c = '\'';
	else if (c >= '0' && c <= '9')	//WARNING: This is not octal, but uses 'yellow' numbers instead (as on hud).
		c = 0xe012 + c - '0';
	else if (c == '\r')
	{	//sigh
		c = *pr_file_p++;
		if (c != '\n')
			QCC_PR_ParseWarning(WARN_HANGINGSLASHR, "Hanging \\\\\r");
		pr_source_line++;
	}
	else if (c == '\n')
	{	//sigh
		pr_source_line++;
	}
	else
		QCC_PR_ParseError (ERR_INVALIDSTRINGIMMEDIATE, "Unknown escape char %c", c);

	return c;
}
void QCC_PR_LexString (void)
{
	unsigned int	c, t;
	int bytecount;
	int		len = 0;
	char	*end;
	const char *cnst;
	int		raw;
	char	rawdelim[64];
	int		stringtype;
			//0 - quake output, input is 8bit. warnings when its not ascii. \u will still give utf-8 text, other chars as-is. Expect \s to screw everything up with utf-8 output.
			//1 - quake output, input is utf-8. due to editors not supporting it, that generally means the input (ab)uses markup.
			//2 - utf-8 output, input is utf-8. welcome to the future! unfortunately not the present.

	int texttype;
	pbool first = true;

	for(;;)
	{
		raw = 0;
		texttype = 0;

		QCC_PR_LexComment(&pr_token_precomment);

		if (flag_qccx && *pr_file_p == ':')
		{
			pr_file_p++;
			pr_token[len++] = 0;
			continue;
		}

		if (*pr_file_p == 'R' && pr_file_p[1] == '\"')
		{
			/*R"delim(fo
			o)delim" -> "fo\no"
			the []
			*/
			raw = 1;
			pr_file_p+=2;

			while (1)
			{
				c = *pr_file_p++;
				if (c == '(')
				{
					rawdelim[0] = ')';
					break;
				}
				if (!c || raw >= sizeof(rawdelim)-1)
					QCC_PR_ParseError (ERR_EOF, "EOF while parsing raw string delimiter. Expected: R\"delim(string)delim\"");
				rawdelim[raw++] = c;
			}
			rawdelim[raw++] = '\"';

			//these two conditions are generally part of the C preprocessor.
			if (!strncmp(pr_file_p, "\\\r\n", 3))
			{	//dos format
				pr_file_p += 3;
				pr_source_line++;
			}
			else if (!strncmp(pr_file_p, "\\\r", 2) || !strncmp(pr_file_p, "\\\n", 2))
			{	//mac + unix format
				pr_file_p += 2;
				pr_source_line++;
			}
			stringtype = 0;
		}
		else if (*pr_file_p == 'Q' && pr_file_p[1] == '\"')
		{	//quake output with utf-8 input (expect to need markup).
			stringtype = 1;
			pr_file_p+=2;
		}
		else if ((*pr_file_p == 'U' || *pr_file_p == 'u' || *pr_file_p == 'L') && pr_file_p[1] == '\"')
		{	//unicode string, char32_t, char16_t, wchar_t respectively. we spit out utf-8 regardless.
			QCC_PR_ParseWarning(WARN_NOTUTF8, "char32_t/char16_t/wchar_t strings are not supported, treating as u8 prefix (as utf-8)");
			stringtype = 2;
			pr_file_p+=2;
		}
		else if (*pr_file_p == 'u' && pr_file_p[1] == '8' && pr_file_p[2] == '\"')
		{	//utf-8 string.
			stringtype = 2;
			pr_file_p+=3;
		}
		else if (*pr_file_p == '\"')
		{
			stringtype = flag_utf8strings?2:0;
			pr_file_p++;
		}
		else if (first)
		{
			stringtype = 0;
			QCC_PR_ParseError(ERR_BADCHARACTERCODE, "Expected string constant");
		}
		else
			break;
		first = false;

		for(;;)
		{
			c = *pr_file_p++;
			if (!c)
				QCC_PR_ParseError (ERR_EOF, "EOF inside quote");

			if (raw)
			{
				//raw strings contain very little parsing. just delimiter and initial \NL support.
				if (c == rawdelim[0] && !strncmp(pr_file_p, rawdelim+1, raw-1))
				{
					pr_file_p += raw-1;
					break;
				}

				//make sure line numbers are correct though.
				if (c == '\r' && *pr_file_p != '\n')
					pr_source_line++;	//mac
				if (c == '\n')	//dos/unix
					pr_source_line++;
				goto forcebyte;
			}
			else
			{
				if (c=='\n')
					QCC_PR_ParseError (ERR_INVALIDSTRINGIMMEDIATE, "newline inside quote");
				if (c=='\\')
				{	// escape char
					c = *pr_file_p;	//peek at it, for our hacks.
					if (c == 's' || c == 'b')
					{
						pr_file_p++;
						texttype ^= 0xe080;
						continue;
					}
					else if (c == '.')
					{
						pr_file_p++;
						c = 0xe01c | texttype;
					}
					else if (c == 'u' || c == 'U')
					{	//special hack, \u is a utf-8 code regardless of output encoding...
						c = QCC_PR_LexEscapedCodepoint();
						goto forceutf8;
					}
					else if (c == 'x' || c == 'X')
					{	//special hack, \xXX in a string is an explicit byte regardless of encoding.
						c = QCC_PR_LexEscapedCodepoint();
//						if (c > 0xff)
//							QCC_PR_ParseWarning(ERR_BADCHARACTERCODE, "Bad unicode character code - codepoint %#x is above 0xFF", c);
						goto forcebyte;
					}
					else
					{
						c = QCC_PR_LexEscapedCodepoint();
//						if (stringtype != 2 && c > 0xff)
//							QCC_PR_ParseWarning(ERR_BADCHARACTERCODE, "Bad legacy character code - codepoint %#x is above 0xFF", c);
					}
				}
				else if (c=='\"')
				{
					break;
				}
				else if (c == '#' && flag_macroinstrings)
				{
					for (end = pr_file_p; ; end++)
					{
						if (qcc_iswhite(*end))
							break;

						if (*end == ')'
							||	*end == '('
							||	*end == '+'
							||	*end == '-'
							||	*end == '*'
							||	*end == '/'
							||	*end == '\\'
							||	*end == '|'
							||	*end == '&'
							||	*end == '='
							||	*end == '^'
							||	*end == '~'
							||	*end == '['
							||	*end == ']'
							||	*end == '\"'
							||	*end == '{'
							||	*end == '}'
							||	*end == ';'
							||	*end == ':'
							||	*end == ','
							||	*end == '.'
							||	*end == '#')
								break;
					}

					c = *end;
					*end = '\0';
					cnst = QCC_PR_CheckCompConstString(pr_file_p);
					if (cnst==pr_file_p)
					{
						if (*pr_file_p)
							QCC_PR_ParseWarning(WARN_MACROINSTRING, "Unable to expand string macro %s", pr_file_p);

					}
					else if (cnst)
					{
						QCC_PR_ParseWarning(WARN_MACROINSTRING, "Macro %s expansion in string", pr_file_p);
						*end = c;

						if (len+strlen(cnst) >= sizeof(pr_token)-1)
							QCC_Error(ERR_INVALIDSTRINGIMMEDIATE, "String length exceeds %u", (unsigned)sizeof(pr_token)-1);

						strcpy(pr_token+len, cnst);
						bytecount=strlen(cnst);
						while (bytecount > 0 && qcc_iswhitesameline(pr_token[len+bytecount-1]))
							bytecount--;	//make sure there's no trailing whitespace on the end.
						len+=bytecount;
						pr_file_p = end;
						continue;
					}
					*end = c;
					c = '#';	//undo
				}
				else if (c == 0x7C && flag_acc)	//reacc support... reacc is strange.
					c = '\n';
				else
				{
					unsigned int cp = c;
					unsigned int len = stringtype?utf8_check(pr_file_p-1, &cp):0;
					if (!len)
					{	//invalid utf-8 encoding? don't treat it as utf-8!
						if (stringtype)
							QCC_PR_ParseWarning(ERR_BADCHARACTERCODE, "Input string is not valid utf-8");
						if (c >= ' ')
							c |= texttype;
						goto forcebyte;
					}
					if (texttype)
					{
						if (cp < ' ')
							c = cp;	//don't mask C0 chars like \t or \n
						else if (cp < 0x80)
							c = cp|0xe080;	//DO mask other ascii chars (and map to the private-use range at the same time, because this isn't standard unicode any more)
						else
						{
							QCC_PR_ParseWarning(ERR_BADCHARACTERCODE, "Unable to mask non-ascii chars. Attempting to mask bytes");
							c |= texttype;
							goto forcequake;
						}
					}
					else
						c = cp;
					pr_file_p += len-1;
				}
			}

//			if (c >= 0x20 && c < 0x80)
//				c |= 0xe000;	//TEST
			if (stringtype == 2)
			{	//we're outputting a utf-8 string.
forceutf8:
				if (c > 0x10FFFFu)	//RFC 3629 imposes the same limit as UTF-16 surrogate pairs.
					QCC_PR_ParseWarning(WARN_NOTUTF8, "Bad unicode character code - codepoint is above 0x10FFFFu");

				//figure out the count of bytes required to encode this char
				bytecount = 1;
				t = 0x80;
				while (c >= t)
				{
					if (bytecount == 1)
						t <<= 4;
					else if (bytecount < 7)
						t <<= 5;
					else
						t <<= 6;
					bytecount++;
				}

				//error if needed
				if (len+bytecount >= sizeof(pr_token))
					QCC_Error(ERR_INVALIDSTRINGIMMEDIATE, "String length exceeds %u", (unsigned)sizeof(pr_token)-1);

				//output it.
				if (bytecount == 1)
					pr_token[len++] = (unsigned char)(c&0x7f);
				else
				{
					t = bytecount*6;
					t = t-6;
					pr_token[len++] = (unsigned char)((c>>t)&(0x0000007f>>bytecount)) | (0xffffff00 >> bytecount);
					do
					{
						t = t-6;
						pr_token[len++] = (unsigned char)((c>>t)&0x3f) | 0x80;
					} while(t);
				}
			}
			else
			{
forcequake:
				//we need to convert it to a quake char...
				if (c >= 0xe000 && c <= 0xe0ff)
					c = c & 0xff;	//this private use range is commonly used for quake's glyphs.
				else if (c >= 0 && c <= 0x7f)
					; //FIXME: SOME c0 codes are known to quake, but many got reused for random glyphs. however I'm going to treat quake as full ascii.
				else if (c >= 0x80)
				{
					//FIXME: spit it out as ^{xxxxxx} instead
					QCC_PR_ParseWarning(WARN_NOTUTF8, "Cannot convert character to quake's charset");
				}

forcebyte:
				if (len >= sizeof(pr_token)-1)
					QCC_Error(ERR_INVALIDSTRINGIMMEDIATE, "String length exceeds %u", (unsigned)sizeof(pr_token)-1);
				pr_token[len] = c;
				len++;
			}
		}
	}

	if (len > sizeof(pr_immediate_string)-1)
		QCC_Error(ERR_INVALIDSTRINGIMMEDIATE, "String length exceeds %u", (unsigned)sizeof(pr_immediate_string)-1);

	pr_token[len] = 0;
	pr_token_type = tt_immediate;
	pr_immediate_type = type_string;
	memcpy(pr_immediate_string, pr_token, len+1);
	pr_immediate_strlen = len;

	/*if (qccwarningaction[WARN_NOTUTF8] && stringtype != 1)
	{
		unsigned int		code;
		size_t c;
		for (c = 0; c < pr_immediate_strlen; )
		{
			len = utf8_check(&pr_token[c], &code);
			if (!len || c+len>pr_immediate_strlen)
			{
				QCC_PR_ParseWarning(WARN_NOTUTF8, "String literal is not valid utf-8");
				break;
			}
			c += len;
		}
	}*/
}

/*
==============
PR_LexNumber
==============
*/
int QCC_PR_LexInteger (void)
{
	int		c;
	int		len;

	len = 0;
	c = *pr_file_p;
	if (pr_file_p[0] == '0' && (pr_file_p[1] == 'x' || pr_file_p[1] == 'X'))
	{
		pr_token[0] = '0';
		pr_token[1] = 'x';
		len = 2;
		c = *(pr_file_p+=2);
	}
	do
	{
		pr_token[len] = c;
		len++;
		pr_file_p++;
		c = *pr_file_p;
	} while ((c >= '0' && c<= '9') || (c == '.'&&pr_file_p[1]!='.') || (c>='a' && c <= 'f'));
	pr_token[len] = 0;
	return atoi (pr_token);
}

#ifdef _MSC_VER
#define longlong __int64
#define LL(x) x##i64
#else
#define longlong long long
#define LL(x) x##ll
#endif

static void QCC_PR_LexNumber (void)
{
	int tokenlen = 0;
	longlong num=0;
	int base=0;
	int c;
	int sign=1;
	if (*pr_file_p == '-')
	{
		sign=-1;
		pr_file_p++;

		pr_token[tokenlen++] = '-';
	}
	if (pr_file_p[0] == '0' && (pr_file_p[1] == 'x' || pr_file_p[1] == 'X'))
	{
		pr_file_p+=2;
		base = 16;

		pr_token[tokenlen++] = '0';
		pr_token[tokenlen++] = 'x';
	}
	else if (pr_file_p[0] == '0')
	{
		pr_file_p++;
		if (*pr_file_p >= '0' && *pr_file_p <= '9')
			QCC_PR_ParseWarning(WARN_GMQCC_SPECIFIC, "A leading 0 is interpreted as base-8.");
		base = 8;

		pr_token[tokenlen++] = '0';
	}

	pr_immediate_type = NULL;
	//assume base 10 if not stated
	if (!base)
		base = 10;

	while((c = *pr_file_p))
	{
		if (c >= '0' && c <= '9' && c < '0'+base)
		{
			pr_token[tokenlen++] = c;
			num*=base;
			num += c-'0';
		}
		else if (c >= 'a' && c <= 'z' && c < 'a'+base-10)
		{
			pr_token[tokenlen++] = c;
			num*=base;
			num += c -'a'+10;
		}
		else if (c >= 'A' && c <= 'Z' && c < 'A'+base-10)
		{
			pr_token[tokenlen++] = c;
			num*=base;
			num += c -'A'+10;
		}
		else if (c == '.' && pr_file_p[1]!='.')
		{
			pr_token[tokenlen++] = c;
			pr_file_p++;
			pr_immediate_type = flag_assume_double?type_double:type_float;
			while(1)
			{
				c = *pr_file_p;
				if (c >= '0' && c <= '9')
				{
					pr_token[tokenlen++] = c;
				}
				else if (c == 'f' || c == 'F')
				{
					pr_file_p++;
					break;
				}
				else if (c == 'd' || c == 'D')
				{
					pr_immediate_type = type_double;
					pr_file_p++;
					break;
				}
				else
				{
					break;
				}
				pr_file_p++;
			}
			pr_token[tokenlen++] = 0;
			if (pr_immediate_type == type_double)
				pr_immediate._double = atof(pr_token);
			else
				pr_immediate._float = (float)atof(pr_token);
			goto checkjunk;
		}
		else if (c == 'f' || c == 'F')
		{
			pr_token[tokenlen++] = c;
			pr_token[tokenlen++] = 0;
			pr_file_p++;
			pr_immediate_type = type_float;
			pr_immediate._float = num*sign;

			num*=sign;
			if ((longlong)pr_immediate._float != (longlong)num)
				QCC_PR_ParseWarning(WARN_OVERFLOW, "numerical overflow");
			goto checkjunk;
		}
		else if (c == 'd' || c == 'D')
		{	//note: conflicts with hex. add a dot before it or something.
			pr_token[tokenlen++] = c;
			pr_token[tokenlen++] = 0;
			pr_file_p++;
			pr_immediate_type = type_double;
			pr_immediate._double = num*sign;

			num*=sign;
			if ((longlong)pr_immediate._double != (longlong)num)
				QCC_PR_ParseWarning(WARN_OVERFLOW, "numerical overflow");
			goto checkjunk;
		}
		else if (c == 'i' || c == 'u' || c == 'l' || c == 'I' || c == 'U' || c == 'L')
		{	//length and sign flags can be any order. LL suffix must have the same case (but not necessarily match the sign suffix)
			int isunsigned;
			int islong = (c == 'l')||(c == 'L');
			pr_token[tokenlen++] = c;
			pr_file_p++;
			if (islong)
			{	//length suffix was first.
				//long-long?
				if (*pr_file_p == c)
					pr_token[tokenlen++] = *pr_file_p++;
				//check for signed suffix...
				c = *pr_file_p;
				isunsigned = (c == 'u')||(c=='U');
				if (c == 'i' || c == 'I' || isunsigned)	//ignore an explicit redundant 'i' char, for not-a-float.
					pr_token[tokenlen++] = *pr_file_p++;
			}
			else
			{
				isunsigned = (c == 'u')||(c=='U');
				//we already made sure it u or i, and its not an l
				c = *pr_file_p;
				if (c == 'l' || c == 'L')
				{
					pr_token[tokenlen++] = *pr_file_p++;
					islong = true;
					//long-long?
					if (*pr_file_p == c)
						pr_token[tokenlen++] = *pr_file_p++;
				}
			}
			pr_token[tokenlen++] = 0;
			num *= sign;
			if (islong)
			{
				pr_immediate_type = (isunsigned)?type_uint64:type_int64;
				pr_immediate._int64 = num;
			}
			else
			{
				pr_immediate_type = (isunsigned)?type_uint:type_integer;
				pr_immediate._int = num;

				if ((longlong)pr_immediate._int != (longlong)num)
				{
					if (((longlong)pr_immediate._int & LL(0xffffffff80000000)) != LL(0xffffffff80000000))
						QCC_PR_ParseWarning(WARN_OVERFLOW, "numerical overflow");
				}
			}
			goto checkjunk;
		}
		else
			break;
		pr_file_p++;
	}
	pr_token[tokenlen++] = 0;

	if (!pr_immediate_type)
	{
		//float f = num;
		if (flag_assume_integer)// || (base != 10 && sign > 0 && (long long)f != (long long)num))
			pr_immediate_type = type_integer;
		else if (flag_qccx && base == 16)
		{
			pr_immediate_type = type_float;
			goto qccxhex;
		}
		else
			pr_immediate_type = type_float;
	}

	if (pr_immediate_type == type_integer)
	{
		pr_immediate_type = type_integer;
qccxhex:
		pr_immediate._int = num*sign;

		num*=sign;
		if ((longlong)pr_immediate._int != (longlong)num)
		{
			if (((longlong)pr_immediate._int & LL(0xffffffff80000000)) != LL(0xffffffff80000000))
					QCC_PR_ParseWarning(WARN_OVERFLOW, "numerical overflow");
		}
	}
	else
	{
		pr_immediate_type = type_float;
		// at this point, we know there's no . in it, so the NaN bug shouldn't happen
		// and we cannot use atof on tokens like 0xabc, so use num*sign, it SHOULD be safe
		//pr_immediate._float = atof(pr_token);
		pr_immediate._float = (float)(num*sign);

		num*=sign;
		if ((longlong)pr_immediate._float != (longlong)num && base == 16)
			QCC_PR_ParseWarning(WARN_OVERFLOW, "numerical overflow %lld will be rounded to %f", num, pr_immediate._float);
	}

checkjunk:
	c = *pr_file_p;
	if ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || (c >= '0' && c <= '9') || (c & 0x80))
		QCC_PR_ParseWarning(ERR_NOTANUMBER, "bad suffix on number %s", pr_token);
}


static float QCC_PR_LexFloat (void)
{
	int		c;
	int		len;

	len = 0;
	c = *pr_file_p;
	do
	{
		pr_token[len] = c;
		len++;
		pr_file_p++;
		c = *pr_file_p;
	} while ((c >= '0' && c<= '9') || (c == '.'&&pr_file_p[1]!='.'));	//only allow a . if the next isn't too...
	if (*pr_file_p == 'f')
		pr_file_p++;
	pr_token[len] = 0;
	return (float)atof (pr_token);
}

/*
==============
PR_LexVector

Parses a single quoted vector
==============
*/
static void QCC_PR_LexVector (void)
{
	int		i;

	pr_file_p++;	//skip the leading ' char

	if (*pr_file_p == '\\')
	{//extended character constant
		pr_file_p++;
		pr_token_type = tt_immediate;
		pr_immediate_type = type_float;
		pr_immediate._float = QCC_PR_LexEscapedCodepoint();
		if (*pr_file_p != '\'')
			QCC_PR_ParseError (ERR_INVALIDVECTORIMMEDIATE, "Bad character constant");
		pr_file_p++;
		return;
	}
	if ((unsigned char)*pr_file_p >= 0x80)
	{
		int b = utf8_check(pr_file_p, &pr_immediate._int);	//utf-8 codepoint.
		pr_token_type = tt_immediate;
		pr_immediate_type = type_float;
		if (flag_qccx)
			QCC_PR_ParseWarning(WARN_DENORMAL, "char constant: denormal");
		else
			pr_immediate._float = pr_immediate._int;
		pr_file_p+=b+1;
		return;
	}
	else if (pr_file_p[1] == '\'')
	{//character constant
		pr_token_type = tt_immediate;
		pr_immediate_type = type_float;
		if (flag_qccx)
		{
			QCC_PR_ParseWarning(WARN_DENORMAL, "char constant: denormal");
			pr_immediate._int = pr_file_p[0];
		}
		else
			pr_immediate._float = pr_file_p[0];
		pr_file_p+=2;
		return;
	}
	pr_token_type = tt_immediate;
	pr_immediate_type = type_vector;
	QCC_PR_LexWhitespace (false);
	for (i=0 ; i<3 ; i++)
	{
		pr_immediate.vector[i] = QCC_PR_LexFloat ();
		QCC_PR_LexWhitespace (false);

		if (*pr_file_p == '\'' && i == 1)
		{
			if (i < 2)
				QCC_PR_ParseWarning (WARN_FTE_SPECIFIC, "2d vector");

			for (i++ ; i<3 ; i++)
				pr_immediate.vector[i] = 0;
			break;
		}
	}
	if (*pr_file_p != '\'')
		QCC_PR_ParseError (ERR_INVALIDVECTORIMMEDIATE, "Bad vector");
	pr_file_p++;
}

/*
==============
PR_LexName

Parses an identifier
==============
*/
static void QCC_PR_LexName (void)
{
	unsigned int		c;
	int		len;

	len = 0;
	do
	{
		int b = utf8_check(pr_file_p, &c);
		if (!b)
		{
			unsigned char lead = *pr_file_p++;
			char *o;
			while(*pr_file_p && !utf8_check(pr_file_p, &c))
				pr_file_p++;
			o = pr_file_p;
			while (qcc_iswhite(*pr_file_p))
			{
				if (*pr_file_p == '\n')
					break;
				pr_file_p++;
			}
			if (*pr_file_p == '\n')
				QCC_PR_ParseError(ERR_NOTANAME, "Invalid UTF-8 code sequence at end of line. Lead byte was %#2x", lead);
			else
			{
				len = 0;
				while (*pr_file_p && !qcc_iswhite(*pr_file_p))
					pr_token[len++] = *pr_file_p++;
				pr_token[len++] = 0;
				pr_file_p = o;
				QCC_PR_ParseError(ERR_NOTANAME, "Invalid UTF-8 code sequence before %s. Lead byte was %#2x", pr_token, lead);
			}
			return;
		}
		while(b-->0)
		{
			pr_token[len] = *pr_file_p++;
			len++;
		}
		c = *pr_file_p;
	} while ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
	|| (c >= '0' && c <= '9') || (c & 0x80));

	pr_token[len] = 0;
	pr_token_type = tt_name;
}

/*
==============
PR_LexPunctuation
==============
*/
static void QCC_PR_LexPunctuation (void)
{
	int		i;
	int		len;
	char	*p;

	pr_token_type = tt_punct;

	if (pr_file_p[0] == '*' && pr_file_p[1] == '*' && flag_dblstarexp)
	{	//for compat with gmqcc. fteqcc uses *^ internally (which does not conflict with multiplying by dereferenced pointers - sucks for MSCLR c++ syntax)
		QCC_PR_ParseWarning(WARN_GMQCC_SPECIFIC, "** is unsafe around pointers, use *^ instead.", pr_token);
		strcpy (pr_token, "*^");
		pr_file_p += 2;
		return;
	}

	for (i=0 ; (p = pr_punctuation[i]) != NULL ; i++)
	{
		len = strlen(p);
		if (!strncmp(p, pr_file_p, len) )
		{
			strcpy (pr_token, pr_punctuationremap[i]);
			if (p[0] == '{')
				pr_bracelevel++;
			else if (p[0] == '}')
				pr_bracelevel--;
			pr_file_p += len;
			return;
		}
	}

	if ((unsigned char)*pr_file_p == (unsigned char)'\\' && pr_file_p[1] == '\r' && pr_file_p[2] == '\n')
		pr_file_p+=3;
	else if ((unsigned char)*pr_file_p == (unsigned char)'\\' && (pr_file_p[1] == '\r' || pr_file_p[1] == '\n'))
		pr_file_p+=2;
	else
	{
		if ((unsigned char)*pr_file_p == (unsigned char)0xa0)
			QCC_PR_ParseWarning (ERR_UNKNOWNPUCTUATION, "Unsupported punctuation: '\\x%x' - non-breaking space", (unsigned char)*pr_file_p);
		else
			QCC_PR_ParseWarning (ERR_UNKNOWNPUCTUATION, "Unknown punctuation: '\\x%x'", *pr_file_p);
		pr_file_p++;
	}

	QCC_PR_Lex();
}


/*
==============
PR_LexWhitespace
==============
*/
void QCC_PR_LexWhitespace (pbool inhibitpreprocessor)
{
	int		c;

	while (1)
	{
	// skip whitespace
		while ((c = *pr_file_p) && qcc_iswhite(c))
		{
			if (qcc_islineending(c, pr_file_p[1]))
			{
				pr_file_p++;
				if (!inhibitpreprocessor)
					QCC_PR_NewLine (false);
				else
					pr_source_line++;
				if (!pr_file_p)
					return;
			}
			else
				pr_file_p++;
		}
		if (c == 0)
			return;		// end of file

	// skip // comments
		if (c=='/' && pr_file_p[1] == '/')
		{
			while (*pr_file_p && !qcc_islineending(pr_file_p[0], pr_file_p[1]))
				pr_file_p++;

			if (*pr_file_p)
				pr_file_p++;	//don't break on eof.
			if (!inhibitpreprocessor)
				QCC_PR_NewLine(false);
			else
				pr_source_line++;
			continue;
		}

	// skip /* */ comments
		if (c=='/' && pr_file_p[1] == '*')
		{
			pr_file_p+=1;
			do
			{
				pr_file_p++;
				if (qcc_islineending(pr_file_p[0], pr_file_p[1]))
				{
					if (!inhibitpreprocessor)
						QCC_PR_NewLine(true);
					else
						pr_source_line++;
				}
				if (pr_file_p[1] == 0)
				{
					QCC_PR_ParseError(0, "EOF inside comment\n");
					pr_file_p++;
					return;
				}
				if (pr_file_p[0] == '/' && pr_file_p[1] == '*')
					QCC_PR_ParseWarning(WARN_NESTEDCOMMENT, "\"/*\" inside comment");
			} while (pr_file_p[0] != '*' || pr_file_p[1] != '/');
			pr_file_p+=2;
			continue;
		}

		break;		// a real character has been found
	}
}

//============================================================================

#define	MAX_FRAMES	8192
char	pr_framemodelname[64];
struct
{
	char name[64];
	int value;
	const char *file;	//compare to s_filen to see if its current or not
} pr_framemacro[MAX_FRAMES];
int		pr_nummacros;
int		pr_macrovalue;	//next value to use
int		pr_savedmacro;	//for sub-groups.

void QCC_PR_ClearGrabMacros (pbool newfile)
{
	if (!newfile)
		pr_nummacros = 0;
	pr_macrovalue = 0;
	pr_savedmacro = -1;
}

static int QCC_PR_FindMacro (char *name)
{
	int		i;

	for (i=pr_nummacros-1 ; i>=0 ; i--)
	{
		if (!STRCMP (name, pr_framemacro[i].name))
		{
			if (pr_framemacro[i].file != s_filen)
				QCC_PR_ParseWarning(WARN_STALEMACRO, "Stale macro used (%s, defined in %s)", pr_token, pr_framemacro[i].file);
			return pr_framemacro[i].value;
		}
	}
	for (i=pr_nummacros-1 ; i>=0 ; i--)
	{
		if (!stricmp (name, pr_framemacro[i].name))
		{
			QCC_PR_ParseWarning(WARN_CASEINSENSITIVEFRAMEMACRO, "Case insensitive frame macro (using %s)", pr_framemacro[i].name);
			if (pr_framemacro[i].file != s_filen)
				QCC_PR_ParseWarning(WARN_STALEMACRO, "Stale macro used (%s, defined in %s)", pr_token, pr_framemacro[i].file);
			return pr_framemacro[i].value;
		}
	}
	return -1;
}

static void QCC_PR_ExpandMacro(void)
{
	int		i = QCC_PR_FindMacro(pr_token);

	if (i < 0)
		QCC_PR_ParseError (ERR_BADFRAMEMACRO, "Unknown frame macro $%s", pr_token);

	QC_snprintfz(pr_token, sizeof(pr_token),"%d", i);
	pr_token_type = tt_immediate;
	pr_immediate_type = type_float;
	pr_immediate._float = (float)i;
}

pbool QCC_PR_SimpleGetString(void)
{
	int		c;
	int		i = 0;
	char *f;

	pr_token[0] = 0;

// skip whitespace
	while ((c = *pr_file_p) && qcc_iswhite(c))
	{
		if (c=='\n')
			return false;
		pr_file_p++;
	}
	if (c == 0)	//eof
		return false;
//abort if there's a comment.
	if (pr_file_p[0] == '/')
	{
		if (pr_file_p[1] == '/')
		{	//comment alert
			while(*pr_file_p && *pr_file_p != '\n')
				pr_file_p++;
			return false;
		}
		if (pr_file_p[1] == '*')
			return false;
	}

	if (*pr_file_p != '\"')
		return false;	//nope, not a string.
	f = pr_file_p+1;
	while (*f)
	{
		if (*f == '\n' || !*f)
		{	//bad string
			QCC_Error (ERR_INTERNAL, "new line inside string");
			pr_token[0] = 0;
			return false;
		}
		if (*f == '\"')
		{	//end-of-string
			pr_token[i] = 0;
			pr_file_p = f+1;
			return false;
		}
		if (i == sizeof(qcc_token)-1)
			QCC_Error (ERR_INTERNAL, "token exceeds %i chars", i);
		if (*f == '\\')
		{
			f++;
			if (!*f)
				f = "";
			else if (*f == 'n')
			{
				pr_token[i++] = '\n';
				f++;
			}
			else if (*f == 'r')
			{
				pr_token[i++] = '\r';
				f++;
			}
			else if (*f == 't')
			{
				pr_token[i++] = '\t';
				f++;
			}
			else		
				pr_token[i++] = *f++;
		}
		else
			pr_token[i++] = *f++;
	}
	return true;
}
// just parses text, returning false if an eol is reached
pbool QCC_PR_SimpleGetToken (void)
{
	int		c;
	int		i;

	pr_token[0] = 0;

// skip whitespace
	while ((c = *pr_file_p) && qcc_iswhite(c))
	{
		if (c=='\n')
			return false;
		pr_file_p++;
	}
	if (c == 0)	//eof
		return false;
	if (pr_file_p[0] == '/')
	{
		if (pr_file_p[1] == '/')
		{	//comment alert
			while(*pr_file_p && *pr_file_p != '\n')
				pr_file_p++;
			return false;
		}
		if (pr_file_p[1] == '*')
			return false;
	}

	i = 0;
	while ((c = *pr_file_p) && !qcc_iswhite(c) && c != ',' && c != ';' && c != ')' && c != '(' && c != ']' && !(c == '/' && pr_file_p[1] == '/'))
	{
		if (i == sizeof(qcc_token)-1)
			QCC_Error (ERR_INTERNAL, "token exceeds %i chars", i);
		pr_token[i] = c;
		i++;
		pr_file_p++;
	}
	pr_token[i] = 0;
	return i!=0;
}

static pbool QCC_PR_LexMacroName(void)
{
	int		c;
	int		i;

	pr_token[0] = 0;

// skip whitespace
	while ((c = *pr_file_p) && qcc_iswhite(c))
	{
		if (c=='\n')
			return false;
		pr_file_p++;
	}
	if (!c)
		return false;
	if (pr_file_p[0] == '/')
	{
		if (pr_file_p[1] == '/')
		{	//comment alert
			while(*pr_file_p && *pr_file_p != '\n')
				pr_file_p++;
			return false;
		}
		if (pr_file_p[1] == '*')
			return false;
	}

	i = 0;
	while ( (c = *pr_file_p) > ' ' && c != '\n' && c != ',' && c != ';' && c != '&' && c != '|' && c != ')' && c != '(' && c != ']' && !(pr_file_p[0] == '.' && pr_file_p[1] == '.'))
	{
		if (i == sizeof(qcc_token)-1)
			QCC_Error (ERR_INTERNAL, "token exceeds %i chars", i);
		pr_token[i] = c;
		i++;
		pr_file_p++;
	}
	pr_token[i] = 0;
	return i!=0;
}

static void QCC_PR_MacroFrame(char *name, int value, pbool force)
{
	int i;
	for (i=pr_nummacros-1 ; i>=0 ; i--)
	{
		if (!STRCMP (name, pr_framemacro[i].name))
		{
			//vanilla macro behaviour is to not realise that there's dupes. lookups find the first, so dupes end up as dead gaps.
			//our caller incremented the value externally
			//so warn+ignore if its from the same file
			if (pr_framemacro[i].file == s_filen && !force)
				QCC_PR_ParseWarning(WARN_DUPLICATEMACRO, "Duplicate macro defined (%s). Rename it.", pr_token);
			else
			{
				pr_framemacro[i].value = value;	//old file, override it, whatever the old value was is redundant now
				pr_framemacro[i].file = s_filen;
			}
			return;
		}
	}

	if (strlen(name)+1 > sizeof(pr_framemacro[0].name))
		QCC_PR_ParseWarning(ERR_TOOMANYFRAMEMACROS, "Name for frame macro %s is too long", name);
	else
	{
		strcpy (pr_framemacro[pr_nummacros].name, name);
		pr_framemacro[pr_nummacros].value = value;
		pr_framemacro[pr_nummacros].file = s_filen;
		pr_nummacros++;
		if (pr_nummacros >= MAX_FRAMES)
			QCC_PR_ParseError(ERR_TOOMANYFRAMEMACROS, "Too many frame macros defined");
	}
}

static void QCC_PR_ParseFrame (void)
{
	while (QCC_PR_LexMacroName ())
	{
		QCC_PR_MacroFrame(pr_token, pr_macrovalue++, false);
	}
}

/*
==============
PR_LexGrab

Deals with counting sequence numbers and replacing frame macros
==============
*/
static void QCC_PR_LexGrab (void)
{
	pr_file_p++;	// skip the $
//	if (!QCC_PR_SimpleGetToken ())
//		QCC_PR_ParseError ("hanging $");
	if (qcc_iswhite(*pr_file_p))
		QCC_PR_ParseError (ERR_BADFRAMEMACRO, "hanging $");
	QCC_PR_LexMacroName();
	if (!*pr_token)
		QCC_PR_ParseError (ERR_BADFRAMEMACRO, "hanging $");

// check for $frame
	if (!STRCMP (pr_token, "frame") || !STRCMP (pr_token, "framesave"))
	{
		QCC_PR_ParseFrame ();
		QCC_PR_Lex ();
	}
// ignore other known $commands - just for model/spritegen
	else if (!STRCMP (pr_token, "cd")
	|| !STRCMP (pr_token, "origin")
	|| !STRCMP (pr_token, "base")
	|| !STRCMP (pr_token, "flags")
	|| !STRCMP (pr_token, "scale")
	|| !STRCMP (pr_token, "skin") )
	{	// skip to end of line
		while (QCC_PR_LexMacroName ())
		;
		QCC_PR_Lex ();
	}
	else if (!STRCMP (pr_token, "flush"))
	{
		QCC_PR_ClearGrabMacros(true);
		while (QCC_PR_LexMacroName ())
		;
		QCC_PR_Lex ();
	}
	else if (!STRCMP (pr_token, "frame_reset"))
	{	//for compat with qfcc. full reset of all frame macros.
		QCC_PR_ClearGrabMacros(false);
		while (QCC_PR_LexMacroName ())
		;
		QCC_PR_Lex ();
	}
	else if (!STRCMP (pr_token, "framevalue"))
	{
		QCC_PR_LexMacroName ();
		pr_macrovalue = atoi(pr_token);

		QCC_PR_Lex ();
	}
	else if (!STRCMP (pr_token, "framerestore"))
	{
		QCC_PR_LexMacroName ();
		QCC_PR_ExpandMacro();
		pr_macrovalue = (int)pr_immediate._float;

		QCC_PR_Lex ();
	}
	else if (!STRCMP (pr_token, "modelname"))
	{
		int i;
		QCC_PR_LexMacroName ();

		if (*pr_framemodelname)
			QCC_PR_MacroFrame(pr_framemodelname, pr_macrovalue, true);

		if (!QC_strlcpy(pr_framemodelname, pr_token, sizeof(pr_framemodelname)))
			QCC_PR_ParseWarning (WARN_STRINGTOOLONG, "$modelname name too long");

		i = QCC_PR_FindMacro(pr_framemodelname);
		if (i)
			pr_macrovalue = i;
		else
			i = 0;

		QCC_PR_Lex ();
	}
// look for a frame name macro
	else
		QCC_PR_ExpandMacro ();
}

//===========================
//compiler constants	- dmw

pbool QCC_PR_UndefineName(const char *name)
{
//	int a;
	CompilerConstant_t *c;
	c = pHash_Get(&compconstantstable, name);
	if (!c)
	{
		QCC_PR_ParseWarning(WARN_UNDEFNOTDEFINED, "Precompiler constant %s was not defined", name);
		return false;
	}

	Hash_Remove(&compconstantstable, name);
	return true;
}

CompilerConstant_t *QCC_PR_DefineName(const char *name)
{
	int i;
	CompilerConstant_t *cnst;

	if (strlen(name) >= MAXCONSTANTNAMELENGTH || !*name)
		QCC_PR_ParseError(ERR_NAMETOOLONG, "Compiler constant name length is too long or short");

	cnst = pHash_Get(&compconstantstable, name);
	if (cnst)
	{
		QCC_PR_ParseWarning(WARN_DUPLICATEDEFINITION, "Duplicate definition for Precompiler constant %s", name);
		Hash_Remove(&compconstantstable, name);
	}

	cnst = qccHunkAlloc(sizeof(CompilerConstant_t));

	cnst->used = false;
	cnst->numparams = -1;
	cnst->evil = false;
	strcpy(cnst->name, name);
	cnst->namelen = strlen(name);
	cnst->value = cnst->name + strlen(cnst->name);
	for (i = 0; i < MAXCONSTANTPARAMS; i++)
		cnst->params[i][0] = '\0';

	pHash_Add(&compconstantstable, cnst->name, cnst, qccHunkAlloc(sizeof(bucket_t)));

	return cnst;
}

void QCC_PR_PreProcessor_Define(pbool append)
{
	char *d;
	char *dbuf;
	int dbuflen;
	char *s;
	int quote=false;
	pbool preprocessorhack = false;
	CompilerConstant_t *cnst, *oldcnst;

	QCC_PR_SimpleGetToken ();

	if (!QCC_PR_SimpleGetToken ())
		QCC_PR_ParseError(ERR_NONAME, "No name defined for compiler constant");

	oldcnst = pHash_Get(&compconstantstable, pr_token);
	if (oldcnst)
		Hash_Remove(&compconstantstable, oldcnst->name);

	cnst = QCC_PR_DefineName(pr_token);

	if (*pr_file_p == '(')
	{
		cnst->numparams = 0;
		pr_file_p++;
		while(qcc_iswhitesameline(*pr_file_p))
			pr_file_p++;
		s = pr_file_p;
		for (;;)
		{
			if (*pr_file_p == ',' || *pr_file_p == ')')
			{
				int nl;
				nl = pr_file_p-s;
				while(qcc_iswhitesameline(s[nl]))
					nl--;
				if (cnst->numparams >= MAXCONSTANTPARAMS)
					QCC_PR_ParseError(ERR_MACROTOOMANYPARMS, "May not have more than %i parameters to a macro", MAXCONSTANTPARAMS);
				if (nl >= MAXCONSTANTPARAMLENGTH)
					QCC_PR_ParseError(ERR_MACROTOOMANYPARMS, "parameter name is too long (max %i)", MAXCONSTANTPARAMLENGTH);
				if (nl == 3 && s[0] == '.' && s[1] == '.' && s[2] == '.')
				{
					cnst->varg = true;
					if (*pr_file_p != ')')
						QCC_PR_ParseError(ERR_MACROTOOMANYPARMS, "varadic argument must be last");
				}
				else
				{
					memcpy(cnst->params[cnst->numparams], s, nl);
					cnst->params[cnst->numparams][nl] = '\0';
					for (nl = 0; nl < cnst->numparams; nl++)
					{
						if (!strcmp(cnst->params[nl], cnst->params[cnst->numparams]))
							QCC_PR_ParseError(ERR_MACROTOOMANYPARMS, "duplicate macro paramter name '%s'", cnst->params[nl]);
					}
					cnst->numparams++;
				}
				if (*pr_file_p++ == ')')
					break;
				while(qcc_iswhitesameline(*pr_file_p))
					pr_file_p++;
				s = pr_file_p;
			}
			if(!*pr_file_p++)
			{
				QCC_PR_ParseError(ERR_EXPECTED, "missing ) in macro parameter list");
				break;
			}
		}
	}
	else cnst->numparams = -1;

	//disable append mode if they're trying to do something stupid
	if (append)
	{
		if (!oldcnst)
			append = false;	//append with no previous define is treated as just a regular define. huzzah.
		else if (cnst->numparams != oldcnst->numparams || cnst->varg != oldcnst->varg)
		{
			QCC_PR_ParseWarning(WARN_DUPLICATEPRECOMPILER, "different number of macro arguments in macro append");
			append = false;
		}
		else
		{
			int i;
			//arguments need to be specified, if only so that appends with arguments are still vaugely readable.
			//argument names need to match because the expansion is too lame to cope if they're different.
			for (i = 0; i < cnst->numparams; i++)
			{
				if (strcmp(cnst->params[i], oldcnst->params[i]))
					break;
			}
			if (i < cnst->numparams)
			{
				QCC_PR_ParseWarning(WARN_DUPLICATEPRECOMPILER, "arguments differ in macro append");
				append = false;
			}
			else
				append = true;
		}
	}

	s = pr_file_p;
	d = dbuf = NULL;
	dbuflen = 0;

	if (append)
	{
		//start with the old value
		int olen = strlen(oldcnst->value);
		dbuflen = olen + 128;
		dbuf = qccHunkAlloc(dbuflen);
		memcpy(dbuf, oldcnst->value, olen);
		d = dbuf + olen;
		*d++ = ' ';
	}

	cnst->fromfile = s_filen;
	cnst->fromline = pr_source_line;

	while(*s == ' ' || *s == '\t')
		s++;
	while(1)
	{
		if ((d - dbuf) + 2 >= dbuflen)
		{
			int len = d - dbuf;
			dbuflen = (len+128) * 2;
			dbuf = qccHunkAlloc(dbuflen);
			memcpy(dbuf, d - len, len);
			d = dbuf + len;
		}

		if( *s == '\\' )
		{
			// read over a newline if necessary
			if( s[1] == '\n' || s[1] == '\r' )
			{
				char *exploitcheck;
				s++;	//skip the \ char
				if (*s == '\r' && s[1] == '\n')
					s++;	//skip the \r. the \n will become part of the macro.
				QCC_PR_NewLine(true);

/*
This began as a bug. It is still evil, but its oh so useful.

In C,
#define foobar \
foo\
bar\
moo

becomes foobarmoo, not foo\nbar\nmoo

#define hacks however, require that it becomes
foo\nbar\nmoo

# cannot be used on the first line of the macro, and then is only valid as the first non-white char of the following lines
so if present, the preceeding \\\n and following \\\n must become an actual \n instead of being stripped.
*/

				for (exploitcheck = s; *exploitcheck && qcc_iswhitesameline(*exploitcheck); exploitcheck++)
					;
				if (*exploitcheck == '#')
				{
					*d++ = '\n';
					if (!cnst->evil)
						QCC_PR_ParseWarning(WARN_EVILPREPROCESSOR, "preprocessor directive within preprocessor macro %s", cnst->name);
					cnst->evil = true;
					preprocessorhack = true;
				}
				else if (preprocessorhack)
				{
					*d++ = '\n';
					preprocessorhack = false;
				}
			}
		}
		else if(*s == '\r' || *s == '\n' || *s == '\0')
		{
			break;
		}
		if (!quote && s[0]=='/'&&s[1]=='/')
			break;	//c++ style comments can just be ignored
		if (!quote && s[0]=='/'&&s[1]=='*')
		{	//multi-line c style comments become part of the define itself. this also negates the need for \ at the end of lines.
			//although we don't bother embedding.
			s+=2;
			for(;;)
			{
				if (!s[0])
				{
					QCC_PR_ParseWarning(WARN_DUPLICATEPRECOMPILER, "EOF inside quote in define %s", cnst->name);
					break;
				}
				if (s[0]=='*'&&s[1]=='/')
				{
					s+=2;
					break;
				}
				if (s[0] == '\n')
					pr_source_line++;
				s++;
			}
			continue;
		}
		if (*s == '\"')
			quote=!quote;

		*d = *s;
		d++;
		s++;
	}
	*d = '\0';

	cnst->value = dbuf;

	if (oldcnst && !append)
	{	//we always warn if it was already defined
		//we use different warning codes so that -Wno-mundane can be used to ignore identical redefinitions.
		if (strcmp(oldcnst->value, cnst->value))
			QCC_PR_ParseWarning(WARN_DUPLICATEPRECOMPILER, "Alternate precompiler definition of %s (%s -> %s)", pr_token, oldcnst->value, cnst->value);
		else
			QCC_PR_ParseWarning(WARN_IDENTICALPRECOMPILER, "Identical precompiler definition of %s", pr_token);
	}

	pr_file_p = s;
}

/* *buffer, *bufferlen and *buffermax should be NULL/0 at the start */
static void QCC_PR_ExpandStrCat(char **buffer, size_t *bufferlen, size_t *buffermax,   char *newdata, size_t newlen)
{
	size_t newmax = *bufferlen + newlen;

	if (newmax < *bufferlen)//check for overflow
	{
		QCC_PR_ParseWarning(ERR_INTERNAL, "exceeds 4gb");
		return;
	}
	if (newmax > *buffermax)
	{
		char *newbuf;
		if (newmax < 64)
			newmax = 64;
		if (newmax < *bufferlen * 2)
		{
			newmax = *bufferlen * 2;
			if (newmax < *bufferlen) /*overflowed?*/
			{
				QCC_PR_ParseWarning(ERR_INTERNAL, "exceeds 4gb");
				return;
			}
		}
		newbuf = realloc(*buffer, newmax);
		if (!newbuf)
		{
			QCC_PR_ParseWarning(ERR_INTERNAL, "out of memory");
			return; /*OOM*/
		}
		*buffer = newbuf;
		*buffermax = newmax;
	}
	memcpy(*buffer + *bufferlen, newdata, newlen);
	*bufferlen += newlen;
	/*no null terminator, remember to cat one if required*/
}
/* *buffer, *bufferlen and *buffermax should be NULL/0 at the start */
static void QCC_PR_ExpandStrCatMarkup(char **buffer, size_t *bufferlen, size_t *buffermax,   char *newdata, size_t newlen)
{
	size_t newmax = *bufferlen + newlen*2;

	if (newmax < *bufferlen)//check for overflow
	{
		QCC_PR_ParseWarning(ERR_INTERNAL, "exceeds 4gb");
		return;
	}
	if (newmax > *buffermax)
	{
		char *newbuf;
		if (newmax < 64)
			newmax = 64;
		if (newmax < *bufferlen * 2)
		{
			newmax = *bufferlen * 2;
			if (newmax < *bufferlen) /*overflowed?*/
			{
				QCC_PR_ParseWarning(ERR_INTERNAL, "exceeds 4gb");
				return;
			}
		}
		newbuf = realloc(*buffer, newmax);
		if (!newbuf)
		{
			QCC_PR_ParseWarning(ERR_INTERNAL, "out of memory");
			return; /*OOM*/
		}
		*buffer = newbuf;
		*buffermax = newmax;
	}

	while (newlen--)
	{
		if (*newdata == '\n')
		{
			(*buffer)[*bufferlen+0] = '\\';
			(*buffer)[*bufferlen+1] = '\n';
			*bufferlen += 2;
		}
		else if (*newdata == '\\')
		{
			(*buffer)[*bufferlen+0] = '\\';
			(*buffer)[*bufferlen+1] = '\\';
			*bufferlen += 2;
		}
		else if (*newdata == '\0')
		{
			(*buffer)[*bufferlen+0] = '\\';
			(*buffer)[*bufferlen+1] = '0';
			*bufferlen += 2;
		}
		else if (*newdata == '\"')
		{
			(*buffer)[*bufferlen+0] = '\\';
			(*buffer)[*bufferlen+1] = '\"';
			*bufferlen += 2;
		}
		else
		{
			(*buffer)[*bufferlen] = *newdata;
			*bufferlen += 1;
		}
		newdata++;
	}
	/*no null terminator, remember to cat one if required*/
}

static const struct tm *QCC_CurrentTime(void)
{
	//if SOURCE_DATE_EPOCH environment is defined, use that as seconds from epoch (and show utc)
	//this helps give reproducable builds (which is for some debian project, demonstrating that noone is hacking binaries).
	const char *env = getenv("SOURCE_DATE_EPOCH");
	time_t t;
	if (env && *env)
	{
		t = strtoull(env, NULL, 0);
		if (t)
			return gmtime(&t);
	}

	t = time(NULL);
	return localtime(&t);
}

static char *QCC_PR_PopenMacro(const char *macroname, const char *cmd, char *retbuf, size_t retbufsize)
{
	char *ret = retbuf;
	char temp[65536], *t = temp;
#ifdef _WIN32
	FILE *f = _popen(cmd, "rt");
#else
	FILE *f = popen(cmd, "r");
#endif
	int len;
	if (!f)
	{
		QCC_PR_ParseWarning(ERR_CONSTANTNOTDEFINED, "%s: Unable to execute \"%s\" for value", macroname, cmd);
		return NULL;
	}
	retbufsize-=3;	// '""\0'
	*retbuf++ = '\"';
	len = fread(temp, 1, sizeof(temp), f);
	if (len < 0)
		len = 0;
	else while (len --> 0 && *t && retbufsize > 1)
	{
		if      (*t == '\"')	*retbuf = '\"';
		else if (*t == '\n')	*retbuf = 'n';
		else if (*t == '\r')	*retbuf = 'r';
		else if (*t == '#')		*retbuf = '#';	//so we don't get preqcc-style expansion in strings.
		else
		{
			*retbuf++ = *t++;
			retbufsize--;
			continue;
		}
		retbuf[0] = '\n';
		retbuf+=2;
		retbufsize-=2;
	}
	*retbuf++ = '\"';
	*retbuf++ = 0;
#ifdef _WIN32
	_pclose(f);
#else
	pclose(f);
#endif
	return ret;
}

static char *QCC_PR_CheckBuiltinCompConst(char *constname, char *retbuf, size_t retbufsize)
{
	if (constname[0] != '_' || constname[1] != '_')
		return NULL;
	if (!strcmp(constname, "__TIME__"))
	{
		strftime( retbuf, retbufsize,	"\"%H:%M\"", QCC_CurrentTime());
		return retbuf;
	}
	if (!strcmp(constname, "__DATE__"))
	{
		strftime( retbuf, retbufsize,	"\"%a %d %b %Y\"", QCC_CurrentTime());
		return retbuf;
	}
	if (!strcmp(constname, "__GITURL__"))
		return QCC_PR_PopenMacro(constname, "git remote get-url origin", retbuf, retbufsize);	//some git url...
	if (!strcmp(constname, "__GITHASH__"))
		return QCC_PR_PopenMacro(constname, "git log -1 --format=%H", retbuf, retbufsize);	//just a hash
	if (!strcmp(constname, "__GITDATE__"))
		return QCC_PR_PopenMacro(constname, "git log -1 --format=%cs", retbuf, retbufsize);	//YYYY-MM-DD
	if (!strcmp(constname, "__GITDATETIME__"))
		return QCC_PR_PopenMacro(constname, "git log -1 --format=%ci", retbuf, retbufsize);	//YYYY-MM-DD HH:MM:SS +TZ
	if (!strcmp(constname, "__GITDESC__"))
		return QCC_PR_PopenMacro(constname, "git describe", retbuf, retbufsize);
	if (!strcmp(constname, "__RAND__"))
	{
		QC_snprintfz(retbuf, retbufsize, "%i", rand());
		return retbuf;
	}
#if defined(SVNREVISION) && defined(SVNDATE)
	if (!strcmp(constname, "__QCCREV__"))
		return STRINGIFY(SVNREVISION); //no M or anything, so you can compare revisions properly
#endif
	if (!strcmp(constname, "__QCCVER__"))
	{
#if defined(SVNREVISION) && defined(SVNDATE)
		return "\"FTEQCC " STRINGIFY(SVNREVISION) " "STRINGIFY(SVNDATE)"\"";
#elif defined(SVNREVISION)
		return "\"FTEQCC " STRINGIFY(SVNREVISION) " "__DATE__"\"";
#else
		return "\""__DATE__"\"";
#endif
	}
	if (!strcmp(constname, "__FILE__"))
	{
		char *erk;
		QC_snprintfz(retbuf, retbufsize, "\"%s\"", s_filen);
		erk = strchr(retbuf, ':');
		if (erk)
		{
			erk[0] = '\"';
			erk[1] = 0;
		}
		return retbuf;
	}
	if (!strcmp(constname, "__LINE__"))
	{
		QC_snprintfz(retbuf, retbufsize, "%i", pr_source_line);
		return retbuf;
	}
	if (!strcmp(constname, "__LINESTR__"))
	{
		QC_snprintfz(retbuf, retbufsize, "\"%i\"", pr_source_line);
		return retbuf;
	}
	if (!strcmp(constname, "__FUNC__") || !strcmp(constname, "__func__"))
	{
		QC_snprintfz(retbuf, retbufsize, "\"%s\"",pr_scope?pr_scope->name:"<NO FUNCTION>");
		return retbuf;
	}
	if (!strcmp(constname, "__NULL__"))
	{
		return "0i";
	}
	return NULL;	//didn't match
}

static pbool QCC_PR_ExpandPreProcessorMacro(CompilerConstant_t *c, char **buffer, size_t *bufferlen, size_t *buffermax)
{
	int p;
	char *start;
	char *starttok;
	char *argsend;
	int argsendline;
	size_t whitestart;
	char *paramoffset[MAXCONSTANTPARAMS+1];
	int param=0, extraparam=0;
	int plevel=0;
	pbool noargexpand;

	char *end;
	char retbuf[256];

	pr_file_p++;
	QCC_PR_LexWhitespace(false);
	start = pr_file_p;
	while(1)
	{
		// handle strings correctly by ignoring them
		if (*pr_file_p == '\"')
		{
			do {
				pr_file_p++;
			} while( (pr_file_p[-1] == '\\' || pr_file_p[0] != '\"') && *pr_file_p && *pr_file_p != '\n' );
		}
		if (*pr_file_p == '(')
			plevel++;
		else if (!plevel && (*pr_file_p == ',' || *pr_file_p == ')'))
		{
			if (*pr_file_p == ',' && c->varg && param >= c->numparams)
				extraparam++;	//skip extra trailing , arguments if we're varging.
			else
			{
				paramoffset[param++] = start;
				start = pr_file_p+1;
				if (*pr_file_p == ')')
				{
					*pr_file_p = '\0';
					pr_file_p++;
					break;
				}
				*pr_file_p = '\0';
				pr_file_p++;
				QCC_PR_LexWhitespace(false);
				start = pr_file_p;
				// move back by one char because we move forward by one at the end of the loop
				pr_file_p--;
				if (param == MAXCONSTANTPARAMS || param > c->numparams)
					QCC_PR_ParseError(ERR_TOOMANYPARAMS, "Too many parameters in macro call");
			}
		} else if (*pr_file_p == ')' )
			plevel--;
		else if(*pr_file_p == '\n')
			QCC_PR_NewLine(false);

		// see that *pr_file_p = '\0' up there? Must ++ BEFORE checking for !*pr_file_p
		pr_file_p++;
		if (!*pr_file_p)
			QCC_PR_ParseError(ERR_EOF, "EOF on macro call");
	}
	if (param < c->numparams)
		QCC_PR_ParseError(ERR_TOOFEWPARAMS, "Not enough macro parameters");
	paramoffset[param] = start;

	*buffer = NULL;
	*bufferlen = 0;
	*buffermax = 0;

//				QCC_PR_LexWhitespace(false);
	argsend = pr_file_p;
	argsendline = pr_source_line;
	pr_file_p = c->value;
	for(;;)
	{
		noargexpand = false;
		whitestart = *bufferlen;
		starttok = pr_file_p;
		/*while(qcc_iswhite(*pr_file_p))	//copy across whitespace
		{
			if (!*pr_file_p)
				break;
			pr_file_p++;
		}*/
		QCC_PR_LexWhitespace(true);
		if (starttok != pr_file_p)
		{
			QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   starttok, pr_file_p - starttok);
		}

		if(*pr_file_p == '\"')
		{
			starttok = pr_file_p;
			do
			{
				pr_file_p++;
			} while( (pr_file_p[-1] == '\\' || pr_file_p[0] != '\"') && *pr_file_p && *pr_file_p != '\n' );
			if(*pr_file_p == '\"')
				pr_file_p++;

			QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   starttok, pr_file_p - starttok);
			continue;
		}
		else if (*pr_file_p == '#')	//if you ask for #a##b you will be shot. use #a #b instead, or chain macros.
		{
			if (pr_file_p[1] == '#')
			{	//concatinate (strip out whitespace before the token)
				*bufferlen = whitestart;
				pr_file_p+=2;
				noargexpand = true;
			}
			else
			{	//stringify
				pr_file_p++;
				pr_file_p = QCC_COM_Parse2(pr_file_p);
				if (!pr_file_p)
					break;

				for (p = 0; p < param; p++)
				{
					if (!STRCMP(qcc_token, c->params[p]))
					{
						QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   "\"", 1);
						QCC_PR_ExpandStrCatMarkup(buffer,bufferlen,buffermax,   paramoffset[p], strlen(paramoffset[p]));
						QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   "\"", 1);
						break;
					}
				}
				if (p == param)
				{
					QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   "#", 1);
					QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   qcc_token, strlen(qcc_token));
					if (!c->evil)
						QCC_PR_ParseWarning(0, "'#' is not followed by a macro parameter in %s", c->name);
				}
				continue;	//already did this one
			}
		}

		end = qcc_token;
		pr_file_p = QCC_COM_Parse2(pr_file_p);
		if (!pr_file_p)
			break;

		for (p = 0; p < c->numparams; p++)
		{
			if (!STRCMP(qcc_token, c->params[p]))
			{
				char *argstart, *argend;

				for (start = pr_file_p; qcc_iswhite(*start); start++)
					;
				if (noargexpand || (start[0] == '#' && start[1] == '#'))
					QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   paramoffset[p], strlen(paramoffset[p]));
				else
				{
					for (argstart = paramoffset[p]; *argstart; argstart = argend)
					{
						argend = argstart;
						while (qcc_iswhite(*argend))
							argend++;
						if (*argend == '\"')
						{
							do
							{
								argend++;
							} while( (argend[-1] == '\\' || argend[0] != '\"') && *argend && *argend != '\n' );
							if(*argend == '\"')
								argend++;
							end = NULL;
						}
						else
						{
							argend = QCC_COM_Parse2(argend);
							if (!argend)
								break;
							end = QCC_PR_CheckBuiltinCompConst(qcc_token, retbuf, sizeof(retbuf));
						}
						//FIXME: we should be testing all defines instead of just built-in ones.
						if (end)
							QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   end, strlen(end));
						else
							QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   argstart, argend-argstart);
					}
				}
				break;
			}
		}
		if (c->varg && !STRCMP(qcc_token, "__VA_ARGS__"))
		{	//c99
			if (param-1 == c->numparams)
				QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   paramoffset[c->numparams], strlen(paramoffset[c->numparams]));
			else if (noargexpand)
			{
				if(*bufferlen>0 && (*buffer)[*bufferlen-1] == ',')
					*bufferlen-=1;
			}
		}
		else if (c->varg && !STRCMP(qcc_token, "__VA_COUNT__"))
		{	//not c99
			char tmp[64];
			if (param < c->numparams)
				QCC_PR_ParseError(ERR_TOOFEWPARAMS, "__VA_COUNT__ without any variable args");
			QC_snprintfz(tmp, sizeof(tmp), "%i", param-1+extraparam);
			QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   tmp, strlen(tmp));
		}
		else if (p == c->numparams)
		{
			/*CompilerConstant_t *c2 = pHash_Get(&compconstantstable, qcc_token);
			if (c2 && c2->numparams >= 0 && *pr_file_p == '(')
			{	//oh dear god this is vile bullshit
				char *sub = NULL;
				size_t sublen;
				size_t submax;
				pr_file_p++;
				if (QCC_PR_ExpandPreProcessorMacro(c, &sub,&sublen,&submax))
				{
					QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   sub, sublen);
				}
				free(sub);
			}
			else*/
				QCC_PR_ExpandStrCat(buffer,bufferlen,buffermax,   qcc_token, strlen(qcc_token));
		}
	}

	for (p = 0; p < param-1; p++)
		paramoffset[p][strlen(paramoffset[p])] = ',';
	paramoffset[p][strlen(paramoffset[p])] = ')';

	if (c->inside>8)
		return false;

	pr_file_p = argsend;
	pr_source_line = argsendline;

	if (flag_debugmacros)
	{
		if (flag_msvcstyle)
			externs->Printf ("%s(%i) : macro %s: %s\n", s_filen, pr_source_line, c->name, pr_file_p);
		else
			externs->Printf ("%s:%i: macro %s: %s\n", s_filen, pr_source_line, c->name, pr_file_p);
	}
	return true;
}

int QCC_PR_CheckCompConst(void)
{
	//FIXME: FOO(SPLAT(FOO(BAR)))
	//the above should expand the inner foo before expanding the outer foo

	char		*initial_file_p = pr_file_p;
	int			initial_line = pr_source_line;

	CompilerConstant_t *c;

	char *end, *tok;
	char retbuf[256];

	for (end = pr_file_p; ; end++)
	{
		if (!*end || qcc_iswhite(*end))
			break;

		if (*end == ')'
			||	*end == '('
			||	*end == '+'
			||	*end == '-'
			||	*end == '*'
			||	*end == '/'
			||	*end == '|'
			||	*end == '&'
			||	*end == '='
			||	*end == '^'
			||	*end == '~'
			||	*end == '['
			||	*end == ']'
			||	*end == '\"'
			||	*end == '{'
			||	*end == '}'
			||	*end == ';'
			||	*end == ':'
			||	*end == ','
			||	*end == '.'
			||	*end == '#')
				break;
	}
	if (!QC_strnlcpy(pr_token, pr_file_p, end-pr_file_p, sizeof(pr_token)))
		return false;	//name too long to be a valid macro

//	externs->Printf("%s\n", pr_token);
	c = pHash_Get(&compconstantstable, pr_token);

	if (c && (!currentchunk || currentchunk->cnst != c))	//macros don't expand themselves
	{
		pr_file_p = initial_file_p+strlen(c->name);
		while(*pr_file_p == ' ' || *pr_file_p == '\t')
			pr_file_p++;
		if (c->numparams>=0)
		{
			if (*pr_file_p == '(')
			{
				char *buffer = NULL;
				size_t bufferlen, buffermax;
				if (!QCC_PR_ExpandPreProcessorMacro(c, &buffer, &bufferlen, &buffermax))
				{
					free(buffer);
					pr_file_p = initial_file_p;
					pr_source_line = initial_line;
					return false;
				}

				if (!bufferlen)
					expandedemptymacro = true;
				else
				{
					QCC_PR_ExpandStrCat(&buffer, &bufferlen, &buffermax,   "\0", 1);
					QCC_PR_IncludeChunkEx(buffer, true, NULL, c);
				}
				expandedemptymacro = true;
				free(buffer);
			}
			else
			{
				//QCC_PR_ParseError(ERR_TOOFEWPARAMS, "Macro without argument list");
				//such macros don't get expanded.
				pr_file_p = initial_file_p;
				pr_source_line = initial_line;
				return false;
			}
		}
		else
		{
			if (c->inside >= 8)
			{
				pr_file_p = initial_file_p;
				pr_source_line = initial_line;
				return false;
			}

			if (*c->value)
				QCC_PR_IncludeChunkEx(c->value, false, NULL, c);
			expandedemptymacro = true;
		}
		return true;
	}

	tok = QCC_PR_CheckBuiltinCompConst(pr_token, retbuf, sizeof(retbuf));
	if (tok)
	{
		pr_file_p = end;
		QCC_PR_IncludeChunkEx(tok, true, NULL, NULL);
		return true;
	}
	return false;
}

const char *QCC_PR_CheckCompConstString(const char *def)
{
	const char *s;

	CompilerConstant_t *c;

	c = pHash_Get(&compconstantstable, def);

	if (c)
	{
		s = QCC_PR_CheckCompConstString(c->value);
		return s;
	}
	return def;
}

CompilerConstant_t *QCC_PR_CheckCompConstDefined(const char *def)
{
	CompilerConstant_t *c = pHash_Get(&compconstantstable, def);
	return c;
}

char *QCC_PR_CheckCompConstTooltip(char *word, char *outstart, char *outend)
{
	int i;
	CompilerConstant_t *c = QCC_PR_CheckCompConstDefined(word);
	if (c)
	{
		char *out = outstart;
		if (c->numparams >= 0)
		{
			QC_snprintfz(out, outend-out, "#define %s(", c->name);
			out += strlen(out);
			for (i = 0; i < c->numparams-1; i++)
			{
				QC_snprintfz(out, outend-out, "%s,", c->params[i]);
				out += strlen(out);
			}
			if (i < c->numparams)
			{
				QC_snprintfz(out, outend-out, "%s", c->params[i]);
				out += strlen(out);
			}
			QC_snprintfz(out, outend-out, ")");
		}
		else
			QC_snprintfz(out, outend-out, "#define %s", c->name);
		out += strlen(out);
		if (c->value && *c->value)
			QC_snprintfz(out, outend-out, "\n%s", c->value);

		return outstart;
	}
	return NULL;
}

//============================================================================

/*
==============
PR_Lex

Sets pr_token, pr_token_type, and possibly pr_immediate and pr_immediate_type
==============
*/
void QCC_PR_Lex (void)
{
	int		c;

	pr_token[0] = 0;

	if (!pr_file_p)
	{
		if (QCC_PR_UnInclude())
		{
			QCC_PR_Lex();
			return;
		}
		pr_token_type = tt_eof;
		return;
	}

	pr_token_precomment = NULL;
	QCC_PR_LexComment(&pr_token_precomment);
//	QCC_PR_LexWhitespace (false);

	pr_token_line_last = pr_token_line;
	pr_token_line = pr_source_line;
	if (currentchunk)
		pr_token_line += currentchunk->currentlinenumber-1;

	if (!pr_file_p)
	{
		if (QCC_PR_UnInclude())
		{
			QCC_PR_Lex();
			return;
		}
		pr_token_type = tt_eof;
		return;
	}

	c = *pr_file_p;

	if (!c)
	{
		if (QCC_PR_UnInclude())
		{
			QCC_PR_Lex();
			return;
		}
		pr_token_type = tt_eof;
		return;
	}

// handle quoted strings as a unit
	if (c == '\"' || ((c == 'R' || c == 'Q' || c == 'u' || c == 'U') && pr_file_p[1] == '\"') || (c == 'u' && pr_file_p[1] == '8' && pr_file_p[2] == '\"'))
	{
		QCC_PR_LexString ();
		return;
	}

// handle quoted vectors as a unit
	if (c == '\'')
	{
		QCC_PR_LexVector ();
		return;
	}

// if the first character is a valid identifier, parse until a non-id
// character is reached
	if ((c == '%') && flag_qccx && (pr_file_p[1] == '-' || (pr_file_p[1] >= '0' && pr_file_p[1] <= '9')))
	{
		//with qccx, %5 is a denormalized float.
		pr_file_p++;
		pr_token_type = tt_immediate;
		pr_immediate_type = type_float;
		QCC_PR_ParseWarning(WARN_DENORMAL, "denormalized immediate");
		pr_immediate._int = QCC_PR_LexInteger ();
		return;
	}
	if ( c == '0' && pr_file_p[1] == 'x')
	{
		pr_token_type = tt_immediate;
		QCC_PR_LexNumber();
		return;
	}
	if ( (c == '.'&&pr_file_p[1]!='.'&&pr_file_p[1] >='0' && pr_file_p[1] <= '9') || (c >= '0' && c <= '9') || ( c=='-' && pr_file_p[1]>='0' && pr_file_p[1] <='9') )
	{
		pr_token_type = tt_immediate;
		QCC_PR_LexNumber ();
		return;
	}

	if (/*!flag_qccx &&*/ c == '#' && !(pr_file_p[1]==')' || pr_file_p[1]==',' || pr_file_p[1]=='\"' || pr_file_p[1]=='-' || (pr_file_p[1]>='0' && pr_file_p[1] <='9')))	//hash and not number
	{
		pr_file_p++;
		if (!QCC_PR_CheckCompConst())
		{
			if (!QCC_PR_SimpleGetToken())
				strcpy(pr_token, "unknown");
			QCC_PR_ParseError(ERR_CONSTANTNOTDEFINED, "Explicit precompiler usage when not defined %s", pr_token);
		}
		else
		{
			QCC_PR_Lex();
			if (pr_token_type == tt_eof)
				QCC_PR_Lex();
		}

		return;
	}

	if ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || (c & 0x80))
	{
		if (flag_hashonly || !QCC_PR_CheckCompConst())	//look for a macro.
			QCC_PR_LexName ();
		else
		{
			//we expanded a macro. we need to read the tokens out of it now though
			QCC_PR_Lex();
			if (pr_token_type == tt_eof)
			{
				if (QCC_PR_UnInclude())
				{
					QCC_PR_Lex();
					return;
				}
				pr_token_type = tt_eof;
			}
		}
		return;
	}

	if (c == '$')
	{
		QCC_PR_LexGrab ();
		return;
	}

// parse symbol strings until a non-symbol is found
	QCC_PR_LexPunctuation ();
}

//=============================================================================

pbool QCC_Temp_Describe(QCC_def_t *def, char *buffer, int buffersize);
void QCC_PR_ParsePrintDef (int type, QCC_def_t *def)
{
	if (!qccwarningaction[type])
		return;
	if (def->filen)
	{
		char tybuffer[512];
		char tmbuffer[512];
		char *modifiers;
		if (QCC_Temp_Describe(def, tmbuffer, sizeof(tmbuffer)))
		{
			externs->Printf ("%s:%i:    (%s)(%s)\n", def->filen, def->s_line, TypeName(def->type, tybuffer, sizeof(tybuffer)), tmbuffer);
		}
		else
		{
			modifiers = "";
			if (def->constant)
				modifiers = "const ";
			else if (def->isstatic)
				modifiers = "static ";
			if (flag_msvcstyle)
				externs->Printf ("%s%s(%i) :    %s%s%s %s%s%s is defined here\n", col_location, def->filen, def->s_line, col_type, modifiers, TypeName(def->type, tybuffer, sizeof(tybuffer)), col_symbol, def->name, col_none);
			else
				externs->Printf ("%s%s:%i:    %s%s%s %s%s%s is defined here\n", col_location, def->filen, def->s_line, col_type, modifiers, TypeName(def->type, tybuffer, sizeof(tybuffer)), col_symbol, def->name, col_none);
		}
	}
}
void QCC_PR_ParsePrintSRef (int type, QCC_sref_t def)
{
	QCC_PR_ParsePrintDef(type, def.sym);
}

void *errorscope;
static void QCC_PR_PrintMacro (qcc_includechunk_t *chunk)
{
	extern pbool verbose;
	if (chunk)
	{
		QCC_PR_PrintMacro(chunk->prev);
		if (chunk->cnst)
		{
#if 1
			externs->Printf ("%s%s:%i: macro %s%s%s is defined here\n", col_location, chunk->cnst->fromfile, chunk->cnst->fromline, col_symbol, chunk->cnst->name, col_none);
#else
			externs->Printf ("%s:%i: expanding %s\n", chunk->currentfilename, chunk->currentlinenumber, chunk->cnst->name);
#endif
			if (verbose)
				externs->Printf ("%s\n", chunk->datastart);
		}
		else
			externs->Printf ("%s:%i:\n", chunk->currentfilename, chunk->currentlinenumber);
	}
}
static void QCC_PR_PrintScope (void)
{
	QCC_PR_PrintMacro(currentchunk);
	if (pr_scope)
	{
		if (errorscope != pr_scope)
			externs->Printf ("in function %s%s%s (line %i),\n", col_symbol, pr_scope->name, col_none, pr_scope->line);
		errorscope = pr_scope;
	}
	else
	{
		if (errorscope)
			externs->Printf ("at global scope,\n");
		errorscope = NULL;
	}
}
void QCC_PR_ResetErrorScope(void)
{
	errorscope = NULL;
}
/*
============
PR_ParseError

Aborts the current file load
============
*/
#ifndef QCC
void editbadfile(const char *file, int line);
#endif
//will abort.
NORETURN void VARGS QCC_PR_ParseError (int errortype, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

#ifndef QCC
	editbadfile(s_filen, pr_source_line);
#endif

	QCC_PR_PrintScope();
	if (flag_msvcstyle)
		externs->Printf ("%s%s(%i) : %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);
	else
		externs->Printf ("%s%s:%i: %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);

	longjmp (pr_parse_abort, 1);
}
//will abort.
NORETURN void VARGS QCC_PR_ParseErrorPrintDef (int errortype, QCC_def_t *def, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

#ifndef QCC
	editbadfile(s_filen, pr_source_line);
#endif
	QCC_PR_PrintScope();
	if (flag_msvcstyle)
		externs->Printf ("%s%s(%i) : %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);
	else
		externs->Printf ("%s%s:%i: %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);

	QCC_PR_ParsePrintDef(WARN_ERROR, def);

	longjmp (pr_parse_abort, 1);
}

NORETURN void VARGS QCC_PR_ParseErrorPrintSRef (int errortype, QCC_sref_t def, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

#ifndef QCC
	editbadfile(s_filen, pr_source_line);
#endif
	QCC_PR_PrintScope();
	if (flag_msvcstyle)
		externs->Printf ("%s%s(%i) : %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);
	else
		externs->Printf ("%s%s:%i: %serror%s: %s\n", col_location, s_filen, pr_source_line, col_error, col_none, string);

	QCC_PR_ParsePrintSRef(WARN_ERROR, def);

	longjmp (pr_parse_abort, 1);
}

static pbool VARGS QCC_PR_PrintWarning (int type, const char *file, int line, const char *string)
{
	char *wnam = QCC_NameForWarning(type);
	if (!wnam)
		wnam = "";

	if (string)
		QCC_PR_PrintScope();

	if (type >= ERR_PARSEERRORS)
	{
		if (!string)
			;
		else if (!file || !*file)
			externs->Printf (":: %serror%s%s: %s\n", col_error, wnam, col_none, string);
		else if (flag_msvcstyle)
			externs->Printf ("%s%s(%i) : %serror%s%s: %s\n", col_location, file, line, col_error, wnam, col_none, string);
		else
			externs->Printf ("%s%s:%i: %serror%s%s: %s\n", col_location, file, line, col_error, wnam, col_none, string);
		pr_error_count++;
	}
	else if (qccwarningaction[type] == 2)
	{	//-werror
		if (!string)
			;
		else if (!file || !*file)
			externs->Printf (":: %swerror%s%s: %s\n", col_error, wnam, col_none, string);
		else if (flag_msvcstyle)
			externs->Printf ("%s%s(%i) : %swerror%s%s: %s\n", col_location, file, line, col_error, wnam, col_none, string);
		else
			externs->Printf ("%s%s:%i: %swerror%s%s: %s\n", col_location, file, line, col_error, wnam, col_none, string);
		pr_error_count++;
	}
	else
	{
		if (!string)
			;
		else if (!file || !*file)
			externs->Printf (":: %swarning%s%s: %s\n", col_warning, wnam, col_none, string);
		else if (flag_msvcstyle)
			externs->Printf ("%s%s(%i) : %swarning%s%s: %s\n", col_location, file, line, col_warning, wnam, col_none, string);
		else
			externs->Printf ("%s%s:%i: %swarning%s%s: %s\n", col_location, file, line, col_warning, wnam, col_none, string);
		pr_warning_count++;
	}
	return true;
}
pbool VARGS QCC_PR_Warning (int type, const char *file, int line, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	if (!qccwarningaction[type])
		return false;

	if (!error)
		return QCC_PR_PrintWarning(type, file, line, NULL);

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

	return QCC_PR_PrintWarning(type, file, line, string);
}

//can be used for errors, qcc execution will continue.
pbool VARGS QCC_PR_ParseWarning (int type, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	if (!qccwarningaction[type])
		return false;

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

	return QCC_PR_PrintWarning(type, s_filen, pr_source_line, string);
}

void VARGS QCC_PR_Note (int type, const char *file, int line, const char *error, ...)
{
	va_list		argptr;
	char		string[1024];

	if (!qccwarningaction[type])
		return;

	va_start (argptr,error);
	QC_vsnprintf (string,sizeof(string)-1, error,argptr);
	va_end (argptr);

	QCC_PR_PrintScope();
	if (!file)
		externs->Printf ("note: %s\n", string);
	else if (flag_msvcstyle)
		externs->Printf ("%s(%i) : note: %s\n", file, line, string);
	else
		externs->Printf ("%s:%i: note: %s\n", file, line, string);
}


/*
=============
PR_Expect

Issues an error if the current token isn't equal to string
Gets the next token
=============
*/
#ifndef COMMONINLINES
void QCC_PR_Expect (const char *string)
{
	if (STRCMP (string, pr_token))
		QCC_PR_ParseError (ERR_EXPECTED, "expected %s%s%s, found %s%s%s", col_location, string, col_none, col_name, pr_token, col_none);
	QCC_PR_Lex ();
}
#endif

void QCC_PR_LexComment(char **comment)
{
	char c;
	char *start;
	int nl;
	char *old;
	int oldlen;
	pbool replace = true;
	pbool nextcomment = true;

	// skip whitespace
	nl = false;
	while(nextcomment)
	{
		nextcomment = false;

		while ((c = *pr_file_p) && qcc_iswhite(c))
		{
			if (qcc_islineending(c, pr_file_p[1]))	//allow new lines, but only if there's whitespace before any tokens, and no double newlines.
			{
				if (nl)
				{
					pr_file_p++;
					QCC_PR_NewLine(false);
					break;
				}
				nl = true;
			}
			else
			{
				pr_file_p++;
				nl = false;
			}
		}
		if (nl)
			break;

		// parse // comments
		if (c=='/' && pr_file_p[1] == '/')
		{
			pr_file_p += 2;
			while (*pr_file_p == ' ' || *pr_file_p == '\t')
				pr_file_p++;
			start = pr_file_p;
			while (*pr_file_p && *pr_file_p != '\n')
				pr_file_p++;

			if (*pr_file_p == '\n')
			{
				pr_file_p++;
				QCC_PR_NewLine(false);
			}

			old = replace?NULL:*comment;
			replace = false;
			oldlen = old?strlen(old)+1:0;
			*comment = qccHunkAlloc(oldlen + (pr_file_p-start)+1);
			if (oldlen)
			{
				memcpy(*comment, old, oldlen-1);
				memcpy(*comment+oldlen-1, "\n", 1);
			}
			memcpy(*comment + oldlen, start, pr_file_p - start);
			oldlen = oldlen+pr_file_p - start;
			while(oldlen > 0 && ((*comment)[oldlen-1] == '\r' || (*comment)[oldlen-1] == '\n' || (*comment)[oldlen-1] == '\t' || (*comment)[oldlen-1] == ' '))
				oldlen--;
			(*comment)[oldlen] = 0;
			nextcomment = true;	//include the next // too
			nl = true;
		}
		// parse /* comments
		else if (c=='/' && pr_file_p[1] == '*' && replace)
		{
			pr_file_p+=1;
			start = pr_file_p+1;

			do
			{
				pr_file_p++;
				if (pr_file_p[0]=='\n')
				{
					QCC_PR_NewLine(true);
				}
				else if (pr_file_p[1] == 0)
				{
					QCC_PR_ParseError(0, "EOF inside comment\n");
					break;
				}
				if (pr_file_p[0] == '/' && pr_file_p[1] == '*')
					QCC_PR_ParseWarning(WARN_NESTEDCOMMENT, "\"/*\" inside comment");
			} while (pr_file_p[0] != '*' || pr_file_p[1] != '/');

			if (pr_file_p[1] == 0)
				break;

			old = replace?NULL:*comment;
			replace = false;
			oldlen = old?strlen(old):0;
			*comment = qccHunkAlloc(oldlen + (pr_file_p-start)+1);
			memcpy(*comment, old, oldlen);
			memcpy(*comment + oldlen, start, pr_file_p - start);
			(*comment)[oldlen+pr_file_p - start] = 0;

			pr_file_p+=2;
		}
	}

	QCC_PR_LexWhitespace(false);
}

pbool QCC_PR_CheckTokenComment(const char *string, char **comment)
{
	if (pr_token_type != tt_punct)
		return false;

	if (STRCMP (string, pr_token))
		return false;

	if (comment)
		QCC_PR_LexComment(comment);

	//and then do the rest properly.
	QCC_PR_Lex ();
	return true;
}
/*
=============
PR_Check

Returns true and gets the next token if the current token equals string
Returns false and does nothing otherwise
=============
*/
#ifndef COMMONINLINES
pbool QCC_PR_CheckToken (const char *string)
{
	if (pr_token_type != tt_punct)
		return false;

	if (STRCMP (string, pr_token))
		return false;

	QCC_PR_Lex ();
	return true;
}

pbool QCC_PR_PeekToken (const char *string)
{
	if (pr_token_type != tt_punct)
		return false;
	if (STRCMP (string, pr_token))
		return false;
	return true;
}

pbool QCC_PR_CheckImmediate (const char *string)
{
	if (pr_token_type != tt_immediate)
		return false;

	if (STRCMP (string, pr_token))
		return false;

	QCC_PR_Lex ();
	return true;
}

pbool QCC_PR_CheckName(const char *string)
{
	if (pr_token_type != tt_name)
		return false;
	if (flag_caseinsensitive)
	{
		if (stricmp (string, pr_token))
			return false;
	}
	else
	{
		if (STRCMP(string, pr_token))
			return false;
	}
	QCC_PR_Lex ();
	return true;
}

pbool QCC_PR_CheckKeyword(int keywordenabled, const char *string)
{
	if (pr_token[0] == '_' && pr_token[1] == '_')
	{
		//lets just always go insensitive with a leading underscore pair.
		if (stricmp(string, pr_token+2))
			return false;
		QCC_PR_Lex ();
		return true;
	}
	else
	{
		if (!keywordenabled)
			return false;
		if (flag_caseinsensitive)
		{
			if (stricmp (string, pr_token))
				return false;
		}
		else
		{
			if (STRCMP(string, pr_token))
				return false;
		}
	}
	QCC_PR_Lex ();
	return true;
}
#endif


/*
============
PR_ParseName

Checks to see if the current token is a valid name
============
*/
char *QCC_PR_ParseName (void)
{
	char	ident[MAX_NAME];
	char *ret;

	if (pr_token_type != tt_name)
	{
		if (pr_token_type == tt_eof)
			QCC_PR_ParseError (ERR_EOF, "unexpected EOF", pr_token);
		else if (strcmp(pr_token, "..."))	//seriously? someone used '...' as an intrinsic NAME?
			QCC_PR_ParseError (ERR_NOTANAME, "\"%s%s%s\" - not a name", col_name, pr_token, col_none);
	}
	if (strlen(pr_token) >= MAX_NAME-1)
		QCC_PR_ParseError (ERR_NAMETOOLONG, "name too long");
	strcpy (ident, pr_token);
	QCC_PR_Lex ();

	ret = qccHunkAlloc(strlen(ident)+1);
	strcpy(ret, ident);
	return ret;
//	return ident;
}

/*
============
PR_FindType

Returns a preexisting complex type that matches the parm, or allocates
a new one and copies it out.
============
*/

//requires EVERYTHING to be the same
static int typecmp_strict(QCC_type_t *a, QCC_type_t *b)
{
	int i;
	if (a == b)
		return 0;
	if (!a || !b)
		return 1;	//different (^ and not both null)

	if (a->type != b->type)
		return 1;
	if (a->num_parms != b->num_parms)
		return 1;
	if (a->vargs != b->vargs)
		return 1;
	if (a->vargcount != b->vargcount)
		return 1;

	if (a->size != b->size)
		return 1;

	if (a->accessors != b->accessors)
		return 1;

	if (STRCMP(a->name, b->name))
		return 1;

	if (typecmp_strict(a->aux_type, b->aux_type))
		return 1;

	i = a->num_parms;
	while(i-- > 0)
	{
		if (STRCMP(a->params[i].paramname, b->params[i].paramname))
			return 1;
		if (typecmp_strict(a->params[i].type, b->params[i].type))
			return 1;
		if (a->params[i].defltvalue.cast || b->params[i].defltvalue.cast)
		{
			if (typecmp_strict(a->params[i].defltvalue.cast, b->params[i].defltvalue.cast) ||
				a->params[i].defltvalue.sym != b->params[i].defltvalue.sym ||
				a->params[i].defltvalue.ofs != b->params[i].defltvalue.ofs)
				return 1;
		}
	}

	return 0;
}

//reports if they're functionally equivelent (allows assignments) 
int typecmp(QCC_type_t *a, QCC_type_t *b)
{
	int i;
	if (a == b)
		return 0;
	if (!a || !b)
		return 1;	//different (^ and not both null)

	if (a->type != b->type)
		return 1;
	if (a->num_parms != b->num_parms)
		return 1;
	if (a->vargs != b->vargs)
		return 1;
	if (a->vargcount != b->vargcount)
		return 1;

	if (a->size != b->size)
		return 1;

	if ((a->type == ev_entity && a->parentclass) || a->type == ev_struct || a->type == ev_union)
	{
		if (STRCMP(a->name, b->name))
			return 1;
	}

	if (typecmp(a->aux_type, b->aux_type))
		return 1;

	i = a->num_parms;
	while(i-- > 0)
	{
		if (a->type != ev_function && STRCMP(a->params[i].paramname, b->params[i].paramname))
			return 1;
		if (typecmp(a->params[i].type, b->params[i].type))
			return 1;
		if (a->params[i].defltvalue.cast || b->params[i].defltvalue.cast)
		{
			if (typecmp(a->params[i].defltvalue.cast, b->params[i].defltvalue.cast) ||
				a->params[i].defltvalue.sym != b->params[i].defltvalue.sym ||
				a->params[i].defltvalue.ofs != b->params[i].defltvalue.ofs)
				return 1;
		}
	}

	return 0;
}

//compares the types, but doesn't complain if there are optional arguments which differ
int typecmp_lax(QCC_type_t *a, QCC_type_t *b)
{
	unsigned int minargs = 0;
	unsigned int t;

	if (a == b)
		return 0;
	if (!a || !b)
		return 1;	//different (^ and not both null)

	if (a->type != b->type)
	{
		if (a->type == ev_accessor && a->parentclass)
			if (!typecmp_lax(a->parentclass, b))
				return 0;
		if (b->type == ev_accessor && b->parentclass)
			if (!typecmp_lax(a, b->parentclass))
				return 0;
		if (a->type != ev_variant && b->type != ev_variant)
			return 1;
	}
	else if (a->size != b->size)
		return 1;

	if (a->vargcount != b->vargcount)
		return 1;

	t = a->num_parms;
	minargs = t;
	t = b->num_parms;
	if (minargs > t)
		minargs = t;

//	if (STRCMP(a->name, b->name))	//This isn't 100% clean.
//		return 1;

	if (typecmp_lax(a->aux_type, b->aux_type))
		return 1;

	//variants and args don't make sense, and are considered equivelent(ish).
	if (a->type == ev_variant || b->type == ev_variant)
		return 0;

	//optional arg types must match, even if they're not specified in one.
	for (t = 0; t < minargs; t++)
	{
		if (a->params[t].type->type != b->params[t].type->type)
			return 1;
		if (a->params[t].out != b->params[t].out)
			return 1;
		//classes/structs/unions are matched on class names rather than the contents of the class
		//it gets too painful otherwise, with recursive definitions.
		if (a->params[t].type->type == ev_entity || a->params[t].type->type == ev_struct || a->params[t].type->type == ev_union)
		{
			if (STRCMP(a->params[t].type->name, b->params[t].type->name))
				return 1;
		}
		else
		{
			if (typecmp_lax(a->params[t].type, b->params[t].type))
				return 1;
		}

		if (a->params[t].defltvalue.cast || b->params[t].defltvalue.cast)
		{
			if (typecmp(a->params[t].defltvalue.cast, b->params[t].defltvalue.cast) ||
				a->params[t].defltvalue.sym != b->params[t].defltvalue.sym ||
				a->params[t].defltvalue.ofs != b->params[t].defltvalue.ofs)
				return 1;
		}
	}
	if (a->num_parms > minargs)
	{
		for (t = minargs; t < a->num_parms; t++)
		{
			if (!a->params[t].optional)
				return 1;
		}
	}
	if (b->num_parms > minargs)
	{
		for (t = minargs; t < b->num_parms; t++)
		{
			if (!b->params[t].optional)
				return 1;
		}
	}

	return 0;
}


QCC_type_t *QCC_PR_DuplicateType(QCC_type_t *in, pbool recurse)
{
	QCC_type_t *out;
	if (!in)
		return NULL;

	out = QCC_PR_NewType(in->name, in->type, false);
	out->aux_type = recurse?QCC_PR_DuplicateType(in->aux_type, recurse):in->aux_type;
	out->num_parms = in->num_parms;
	out->params = qccHunkAlloc(sizeof(*out->params) * out->num_parms);
	memcpy(out->params, in->params, sizeof(*out->params) * out->num_parms);
	out->accessors = in->accessors;
	out->size = in->size;
	out->num_parms = in->num_parms;
	out->name = in->name;
	out->parentclass = in->parentclass;

	return out;
}

static void Q_strlcat(char *dest, const char *src, int sizeofdest)
{
	if (sizeofdest)
	{
		int dlen = strlen(dest);
		int slen = strlen(src)+1;
		memcpy(dest+dlen, src, min((sizeofdest-1)-dlen, slen));
		dest[sizeofdest - 1] = 0;
	}
}

char *TypeName(QCC_type_t *type, char *buffer, int buffersize)
{
	char *ret;

	if (type->type == ev_void)
	{
		if (buffersize < 0)
			return buffer;
		*buffer = 0;
		Q_strlcat(buffer, "void", buffersize);
		return buffer;
	}
	if (type->type == ev_enum)
	{
		if (buffersize < 0)
			return buffer;
		*buffer = 0;
		Q_strlcat(buffer, "enum ", buffersize);
		Q_strlcat(buffer, type->name, buffersize);
		Q_strlcat(buffer, ":", buffersize);
		TypeName(type->aux_type, buffer+strlen(buffer), buffersize-strlen(buffer));
		return buffer;
	}
	if (type->type == ev_struct)
	{
		if (buffersize < 0)
			return buffer;
		*buffer = 0;
		Q_strlcat(buffer, "struct ", buffersize);
		Q_strlcat(buffer, type->name, buffersize);
		return buffer;
	}
	if (type->type == ev_union)
	{
		if (buffersize < 0)
			return buffer;
		*buffer = 0;
		Q_strlcat(buffer, "union ", buffersize);
		Q_strlcat(buffer, type->name, buffersize);
		return buffer;
	}

	if (type->type == ev_pointer)
	{
		if (buffersize < 0)
			return buffer;
		TypeName(type->aux_type, buffer, buffersize-2);
		Q_strlcat(buffer, " *", buffersize);
		return buffer;
	}

	ret = buffer;
	if (type->type == ev_field)
	{
		type = type->aux_type;
		*ret++ = '.';
	}
	*ret = 0;

	if (type->type == ev_function)
	{
		int args = type->num_parms;
		pbool vargs = type->vargs;
		unsigned int i;
		Q_strlcat(buffer, type->aux_type->name, buffersize);
		Q_strlcat(buffer, "(", buffersize);
		for (i = 0; i < type->num_parms; )
		{
			if (type->params[i].out)
				Q_strlcat(buffer, "inout ", buffersize);
			if (type->params[i].optional)
				Q_strlcat(buffer, "optional ", buffersize);
			args--;

			Q_strlcat(buffer, type->params[i].type->name, buffersize);
			if (type->params[i].paramname && *type->params[i].paramname)
			{
				Q_strlcat(buffer, " ", buffersize);
				Q_strlcat(buffer, type->params[i].paramname, buffersize);
			}

			if (type->params[i].defltvalue.cast)
			{
				Q_strlcat(buffer, " = ", buffersize);
				Q_strlcat(buffer, QCC_VarAtOffset(type->params[i].defltvalue), buffersize);
			}

			if (++i < type->num_parms || vargs)
				Q_strlcat(buffer, ", ", buffersize);
		}
		if (vargs)
			Q_strlcat(buffer, "...", buffersize);
		Q_strlcat(buffer, ")", buffersize);
	}
	else if (type->type == ev_entity && type->parentclass)
	{
		ret = buffer;
		*ret = 0;
		Q_strlcat(buffer, "class ", buffersize);
		Q_strlcat(buffer, type->name, buffersize);
/*		strcat(ret, " {");
		type = type->param;
		while(type)
		{
			strcat(ret, type->name);
			type = type->next;

			if (type)
				strcat(ret, ", ");
		}
		strcat(ret, "}");
*/
	}
	else
		Q_strlcat(buffer, type->name, buffersize);

	return buffer;
}
//#define typecmp(a, b) (a && ((a)->type==(b)->type) && !STRCMP((a)->name, (b)->name))

static QCC_type_t *QCC_PR_FindType (QCC_type_t *type)
{
	int t;
	for (t = 0; t < numtypeinfos; t++)
	{
//		check = &qcc_typeinfo[t];
		if (typecmp_strict(&qcc_typeinfo[t], type))
			continue;

//		c2 = check->next;
//		n2 = type->next;
//		for (i=0 ; n2&&c2 ; i++)
//		{
//			if (!typecmp((c2), (n2)))
//				break;
//			c2=c2->next;
//			n2=n2->next;
//		}

//		if (n2==NULL&&c2==NULL)
		{
			return &qcc_typeinfo[t];
		}
	}

	type = QCC_PR_DuplicateType(type, false);
	return type;
}
/*
QCC_type_t *QCC_PR_NextSubType(QCC_type_t *type, QCC_type_t *prev)
{
	int p;
	if (!prev)
		return type->next;

	for (p = prev->num_parms; p; p--)
		prev = QCC_PR_NextSubType(prev, NULL);
	if (prev->num_parms)

	switch(prev->type)
	{
	case ev_function:

	}

	return prev->next;
}
*/

QCC_type_t *QCC_TypeForName(const char *name)
{
	return pHash_Get(&typedeftable, name);
/*
	int i;

	for (i = 0; i < numtypeinfos; i++)
	{
		if (qcc_typeinfo[i].typedefed && !STRCMP(qcc_typeinfo[i].name, name))
		{
			return &qcc_typeinfo[i];
		}
	}

	return NULL;*/
}

/*
============
PR_SkipToSemicolon

For error recovery, also pops out of nested braces
============
*/
void QCC_PR_SkipToSemicolon (void)
{
	//escape out of any #define
	while (currentchunk && currentchunk->cnst)
		QCC_PR_UnInclude();

	do
	{
		if (!pr_bracelevel && QCC_PR_CheckToken (";"))
			return;
		QCC_PR_Lex ();
	} while (pr_token_type != tt_eof);
}


/*
============
PR_ParseType

Parses a variable type, including field and functions types
============
*/
#ifdef MAX_EXTRA_PARMS
char	pr_parm_names[MAX_PARMS+MAX_EXTRA_PARMS][MAX_NAME];
#else
char	pr_parm_names[MAX_PARMS][MAX_NAME];
#endif
char *pr_parm_argcount_name;

int recursivefunctiontype;

QCC_type_t *QCC_PR_MakeThiscall(QCC_type_t *orig, QCC_type_t *thistype)
{
	QCC_type_t	ftype = *orig;

	ftype.ptrto = NULL;
	ftype.typedefed = false;
	ftype.num_parms++;
	ftype.params = qccHunkAlloc(sizeof(*ftype.params) * ftype.num_parms);
	memcpy(ftype.params+1, orig->params, sizeof(*ftype.params) * orig->num_parms);
	ftype.params[0].paramname = "this";
	ftype.params[0].type = QCC_PR_PointerType(thistype);
	ftype.params[0].isvirtual = true;

	memmove(&pr_parm_names[1], &pr_parm_names[0], sizeof(*pr_parm_names)*orig->num_parms);
	strcpy(pr_parm_names[0], "this");

	orig = QCC_PR_FindType (&ftype);
	if (!orig)
	{
		orig = QCC_PR_NewType(ftype.name, ftype.type, false);
		*orig = ftype;
	}
	return orig;
}

//expects a ( to have already been parsed.
QCC_type_t *QCC_PR_ParseFunctionType (int newtype, QCC_type_t *returntype)
{
	QCC_type_t	*ftype, *t;
	char	*name;
	int definenames = !recursivefunctiontype;
	int numparms = 0;
	struct QCC_typeparam_s paramlist[MAX_PARMS+MAX_EXTRA_PARMS];

	recursivefunctiontype++;

	ftype = QCC_PR_NewType(type_function->name, ev_function, false);

	ftype->aux_type = returntype;	// return type
	ftype->num_parms = 0;

	if (definenames)
		pr_parm_argcount_name = NULL;

	if (!QCC_PR_CheckToken (")"))
	{
		do
		{
			pbool foundinout;
			if (ftype->num_parms>=MAX_PARMS+MAX_EXTRA_PARMS)
				QCC_PR_ParseError(ERR_TOOMANYTOTALPARAMETERS, "Too many parameters. Sorry. (limit is %i)\n", MAX_PARMS+MAX_EXTRA_PARMS);

			if (QCC_PR_CheckToken ("..."))
			{
				t = QCC_PR_ParseType(false, true);	//the evil things I do...
				if (!t)
				{
					ftype->vargs = true;
					break;
				}
				else
				{	//its a ... followed by a type... don't bug out...
					t = QCC_PR_FieldType(t);
					t = QCC_PR_FieldType(t);
					t = QCC_PR_FieldType(t);
					paramlist[numparms].type = t;
					foundinout = false;
				}
			}
			else
			{
				foundinout = false;
				paramlist[numparms].optional = false;
				paramlist[numparms].isvirtual = false;
				paramlist[numparms].out = false;

				while(1)
				{
					if (!paramlist[numparms].optional && QCC_PR_CheckKeyword(keyword_optional, "optional"))
						paramlist[numparms].optional = true;
					else if (!foundinout && QCC_PR_CheckKeyword(keyword_inout, "inout"))
					{
						paramlist[numparms].out = true;
						foundinout = true;
					}
					else if (!foundinout && QCC_PR_CheckKeyword(keyword_inout, "out"))
					{
						paramlist[numparms].out = 2;	//not really supported, but parsed for readability.
						foundinout = true;
					}
					else if (!foundinout && QCC_PR_CheckKeyword(keyword_inout, "in"))
					{
						paramlist[numparms].out = false;
						foundinout = true;
					}
					else
						break;
				}

				t = QCC_PR_ParseType(false, false);
			}
			paramlist[numparms].defltvalue.cast = NULL;
			paramlist[numparms].ofs = 0;
			paramlist[numparms].arraysize = 0;
			paramlist[numparms].type = t;
			if (!paramlist[numparms].type)
				QCC_PR_ParseError(0, "Expected type\n");

			while (QCC_PR_CheckToken("*"))
				paramlist[numparms].type = QCC_PointerTypeTo(paramlist[numparms].type);

			if (paramlist[numparms].type->type == ev_void)
				break; //float(void) has no actual args

			if (!foundinout && QCC_PR_CheckToken("&"))
			{	//accept c++ syntax, at least on arguments. its not quite the same, but it'll do.
				paramlist[numparms].out = true;
				foundinout = true;
			}

//			type->name = "FUNC PARAMETER";

			paramlist[numparms].paramname = "";
			if (STRCMP(pr_token, ",") && STRCMP(pr_token, ")"))
			{
				if (QCC_PR_CheckToken ("..."))
				{
					ftype->vargs = true;
					break;
				}
				newtype = true;
				name = QCC_PR_ParseName ();
				paramlist[numparms].paramname = qccHunkAlloc(strlen(name)+1);
				strcpy(paramlist[numparms].paramname, name);
				if (definenames)
					strcpy (pr_parm_names[numparms], name);

				if (QCC_PR_CheckToken("["))
				{
					if (QCC_PR_CheckToken("]"))	//length omitted. just treat it as a pointer...?
					{
						QCC_PR_ParseError(0, "unsized array argument\n");
						paramlist[numparms].type = QCC_PointerTypeTo(paramlist[numparms].type);
					}
					else
					{	//proper array
						paramlist[numparms].arraysize = QCC_PR_IntConstExpr();
						if (!paramlist[numparms].arraysize)
							QCC_PR_ParseError(ERR_NOTANAME, "cannot cope with 0-sized arrays");
						QCC_PR_Expect("]");
					}
				}
			}
			else if (definenames)
				strcpy (pr_parm_names[numparms], "");

			if (QCC_PR_CheckToken("="))
			{
				paramlist[numparms].defltvalue = QCC_PR_ParseDefaultInitialiser(paramlist[numparms].type);
				QCC_FreeTemp(paramlist[numparms].defltvalue);
			}
			numparms++;
		} while (QCC_PR_CheckToken (","));

		if (ftype->vargs)
		{
			if (!QCC_PR_CheckToken (")"))
			{
				name = QCC_PR_ParseName();
				if (definenames)
				{
					pr_parm_argcount_name = qccHunkAlloc(strlen(name)+1);
					strcpy(pr_parm_argcount_name, name);
				}
				ftype->vargcount = true;
				QCC_PR_Expect (")");
			}
		}
		else
			QCC_PR_Expect (")");
	}
	ftype->num_parms = numparms;
	ftype->params = qccHunkAlloc(sizeof(*ftype->params) * numparms);
	memcpy(ftype->params, paramlist, sizeof(*ftype->params) * numparms);
	recursivefunctiontype--;

	if (returntype->size > 3 && !autoprototype)	//fixme: handle properly, without breaking __out
		QCC_PR_ParseWarning(WARN_UNDESIRABLECONVENTION, "Unable to handle functions returning structures larger than a vector. Will truncate.");

	if (newtype)
		return ftype;
	return QCC_PR_FindType (ftype);
}
QCC_type_t *QCC_PR_ParseFunctionTypeReacc (int newtype, QCC_type_t *returntype)
{
	QCC_type_t	*ftype, *nptype;
	char	*name;
	int definenames = !recursivefunctiontype;
	int numparms = 0;
	struct QCC_typeparam_s paramlist[MAX_PARMS+MAX_EXTRA_PARMS];

	recursivefunctiontype++;

	ftype = QCC_PR_NewType(type_function->name, ev_function, false);

	ftype->aux_type = returntype;	// return type
	ftype->num_parms = 0;

	pr_parm_argcount_name = NULL;

	if (!QCC_PR_CheckToken (")"))
	{
		do
		{
			if (numparms>=MAX_PARMS+MAX_EXTRA_PARMS)
				QCC_PR_ParseError(ERR_TOOMANYTOTALPARAMETERS, "Too many parameters. Sorry. (limit is %i)\n", MAX_PARMS+MAX_EXTRA_PARMS);

			if (QCC_PR_CheckToken ("..."))
			{
				ftype->vargs = true;
				break;
			}

			if (QCC_PR_CheckName("arg"))
			{
				name = "";
				nptype = QCC_PR_NewType("Variant", ev_variant, false);
			}
			else if (QCC_PR_CheckName("vect"))	//this can only be of vector sizes, so...
			{
				name = "";
				nptype = QCC_PR_NewType("Vector", ev_vector, false);
			}
			else
			{
				name = QCC_PR_ParseName();
				QCC_PR_Expect(":");
				nptype = QCC_PR_ParseType(true, false);
			}

			if (!nptype)
				QCC_PR_ParseError(0, "Expected type\n");
			if (nptype->type == ev_void)
				break;
//			type->name = "FUNC PARAMETER";

			paramlist[numparms].out = false;
			paramlist[numparms].optional = false;
			paramlist[numparms].isvirtual = false;
			paramlist[numparms].ofs = 0;
			paramlist[numparms].arraysize = 0;
			paramlist[numparms].type = nptype;

			if (!*name)
				paramlist[numparms].paramname = "";
			else
			{
				paramlist[numparms].paramname = qccHunkAlloc(strlen(name)+1);
				strcpy(paramlist[numparms].paramname, name);
			}
			if (definenames)
				QC_snprintfz(pr_parm_names[numparms], MAX_NAME, "%s", name);

			numparms++;
		} while (QCC_PR_CheckToken (";"));
		QCC_PR_Expect (")");
	}
	ftype->num_parms = numparms;
	ftype->params = qccHunkAlloc(sizeof(*ftype->params) * numparms);
	memcpy(ftype->params, paramlist, sizeof(*ftype->params) * numparms);
	recursivefunctiontype--;
	if (newtype)
		return ftype;
	return QCC_PR_FindType (ftype);
}
QCC_type_t *QCC_PR_PointerType (QCC_type_t *pointsto)
{
	QCC_type_t	*ptype;
	char name[128];
	if (pointsto->ptrto)
		return pointsto->ptrto;
	QC_snprintfz(name, sizeof(name), "%s*", pointsto->name);
	ptype = QCC_PR_NewType(strcpy(qccHunkAlloc(strlen(name)+1), name), ev_pointer, false);
	ptype->aux_type = pointsto;
	return pointsto->ptrto = QCC_PR_FindType (ptype);
}
QCC_type_t *QCC_PR_FieldType (QCC_type_t *pointsto)
{
	QCC_type_t	*ptype;
	char name[128];
	if (pointsto->fldto)
		return pointsto->fldto;
	QC_snprintfz(name, sizeof(name), ".%s", pointsto->name);
	ptype = QCC_PR_NewType(strcpy(qccHunkAlloc(strlen(name)+1), name), ev_field, false);
	ptype->aux_type = pointsto;
	ptype->size = ptype->aux_type->size;
	return pointsto->fldto = QCC_PR_FindType (ptype);
}
QCC_type_t *QCC_PR_GenFunctionType (QCC_type_t *rettype, struct QCC_typeparam_s *args, int numargs)
{
	int i;
	struct QCC_typeparam_s *p;
	QCC_type_t *ftype;
	ftype = QCC_PR_NewType("$func", ev_function, false);
	ftype->aux_type = rettype;
	ftype->num_parms = numargs;
	ftype->params = p = qccHunkAlloc(sizeof(*ftype->params)*numargs);
	ftype->vargs = false;
	ftype->vargcount = false;
	for (i = 0; i < numargs; i++, p++)
	{
		if (args[i].paramname)
		{
			p->paramname = qccHunkAlloc(strlen(args[i].paramname)+1);
			strcpy(p->paramname, args[i].paramname);
		}
		else
			p->paramname = "";
		p->type = args[i].type;
		p->out = args[i].out;
		p->optional = args[i].optional;
		p->isvirtual = args[i].isvirtual;
		p->ofs = args[i].ofs;
		p->arraysize = args[i].arraysize;
		p->defltvalue.cast = NULL;
	}
	return QCC_PR_FindType (ftype);
}

extern char *basictypenames[];
extern QCC_type_t **basictypes[];
pbool type_inlinefunction;
/*newtype=true: creates a new type always
  silentfail=true: function is permitted to return NULL if it was not given a type, otherwise never returns NULL
*/
QCC_type_t *QCC_PR_ParseType (int newtype, pbool silentfail)
{
	QCC_type_t	*newparm;
	QCC_type_t	*newt;
	QCC_type_t	*type;
	char	*name;
	etype_t structtype;

	type_inlinefunction = false;	//doesn't really matter so long as its not from an inline function type

//	int ofs;

	if (QCC_PR_CheckKeyword(keyword_const, "const"))
	{
		QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "ignoring unsupported const keyword");
		silentfail = false;	//FIXME
	}

	if (QCC_PR_PeekToken ("...") )	//this is getting stupid
	{
		QCC_PR_LexWhitespace (false);
		if (*pr_file_p == '(')
		{	//work around gmqcc's "(...(" being misinterpreted as a cast syntax error, instead abort here so it can be treated as an intrinsic (with args) instead.
			if (silentfail)
				return NULL;
			QCC_PR_ParseError (ERR_NOTATYPE, "\"%s\" is not a type", pr_token);
		}
		QCC_PR_Lex ();

		type = QCC_PR_NewType("FIELD_TYPE", ev_field, false);
		type->aux_type = QCC_PR_ParseType (false, false);
		type->size = type->aux_type->size;

		newt = QCC_PR_FindType (type);
		type = QCC_PR_NewType("FIELD_TYPE", ev_field, false);
		type->aux_type = newt;
		type->size = type->aux_type->size;

		newt = QCC_PR_FindType (type);
		type = QCC_PR_NewType("FIELD_TYPE", ev_field, false);
		type->aux_type = newt;
		type->size = type->aux_type->size;

		if (newtype)
			return type;
		return QCC_PR_FindType (type);
	}
	if (QCC_PR_CheckToken (".."))	//so we don't end up with the user specifying '. .vector blah' (hexen2 added the .. token for array ranges)
	{
		newt = QCC_PR_NewType("FIELD_TYPE", ev_field, false);
		newt->aux_type = QCC_PR_ParseType (false, false);

		newt->size = newt->aux_type->size;

		newt = QCC_PR_FindType (newt);

		type = QCC_PR_NewType("FIELD_TYPE", ev_field, false);
		type->aux_type = newt;

		type->size = type->aux_type->size;

		if (newtype)
			return type;
		return QCC_PR_FindType (type);
	}
	if (QCC_PR_CheckToken ("."))
	{
		//.float *foo; is annoying.
		//technically it is a pointer to a .float
		//most people will want a .(float*) foo;
		//so .*float will give you that.
		//however, we can't cope parsing that with regular types, so we support that ONLY when . was already specified.
		//this is pretty much an evil syntax hack.
		pbool ptr = QCC_PR_CheckToken ("*");
		type = QCC_PR_ParseType(false, false);
		if (!type)
			QCC_PR_ParseError(0, "Expected type\n");
		if (ptr)
			type = QCC_PointerTypeTo(type);

		name = qccHunkAlloc(strlen(type->name)+2);
		*name = '.';
		strcpy(name+1, type->name);

		newt = QCC_PR_NewType(name, ev_field, false);
		newt->aux_type = type;
		newt->size = newt->aux_type->size;

		if (newtype)
			return newt;
		return QCC_PR_FindType (newt);
	}

	name = pr_token;
	if (pr_token_type != tt_name)
	{
		if (silentfail)
			return NULL;
		QCC_PR_ParseError (ERR_NOTATYPE, "\"%s\" is not a type", name);
	}
//	name = QCC_PR_CheckCompConstString(name);

	//accessors
	if (QCC_PR_CheckKeyword (keyword_accessor, "accessor"))
	{
		char parentname[256];
		char *accessorname;
		char *funcname;

		newt = NULL;

		funcname = QCC_PR_ParseName();
		accessorname = qccHunkAlloc(strlen(funcname)+1);
		strcpy(accessorname, funcname);

		/* Look to see if this type is already defined */
		newt = QCC_TypeForName(accessorname);
		if (newt && newt->type != ev_accessor)
			QCC_PR_ParseError(ERR_NOTANAME, "Type %s cannot be redefined as an accessor", accessorname);

		if (QCC_PR_CheckToken(":"))
		{
			type = QCC_PR_ParseType(false, false);
			if (type)
				TypeName(type, parentname, sizeof(parentname));
			else
				strcpy(parentname, "??");

			if (!type || type->type == ev_struct || type->type == ev_union)
				QCC_PR_ParseError(ERR_NOTANAME, "Accessor %s cannot be based upon %s", accessorname, parentname);
		}
		else
			type = NULL;

		if (!newt)
		{
			newt = QCC_PR_NewType(accessorname, ev_accessor, true);
			newt->size=type->size;
		}
		if (!newt->parentclass)
		{
			newt->parentclass = type;
			if (!newt->parentclass || newt->parentclass->type == ev_struct || newt->parentclass->type == ev_union || newt->size != newt->parentclass->size)
				QCC_PR_ParseError(ERR_NOTANAME, "Accessor %s cannot be based upon %s", accessorname, parentname);
		}
		else if (type != newt->parentclass)
			QCC_PR_ParseError(ERR_NOTANAME, "Accessor %s basic type mismatch", accessorname);

		if (QCC_PR_CheckToken("{"))
		{
			struct accessor_s  *acc;
			pbool setnotget;
			char *fieldtypename;
			QCC_type_t *fieldtype;
			QCC_type_t *indextype;
			QCC_sref_t def;
			QCC_type_t *functype;
			struct QCC_typeparam_s arg[3];
			int args;
			char *indexname;
			pbool isref;
			pbool isinline;


			do
			{
				isinline = QCC_PR_CheckName("inline");

				if (QCC_PR_CheckName("set"))
					setnotget = true;
				else if (QCC_PR_CheckName("get"))
					setnotget = false;
				else
					break;
				if (QCC_PR_CheckToken("&"))
					isref = 2;
				else
					isref = QCC_PR_CheckToken("*");

				fieldtypename = QCC_PR_ParseName();
				fieldtype = QCC_TypeForName(fieldtypename);
				if (!fieldtype)
					QCC_PR_ParseError(ERR_NOTATYPE, "Invalid type: %s", fieldtypename);
				while(QCC_PR_CheckToken("*"))
					fieldtype = QCC_PR_PointerType(fieldtype);

				if (pr_token_type != tt_punct)
				{
					funcname = QCC_PR_ParseName();
					accessorname = qccHunkAlloc(strlen(funcname)+1);
					strcpy(accessorname, funcname);
				}
				else
					accessorname = "";

				indextype = NULL;
				indexname = "index";
				if (QCC_PR_CheckToken("["))
				{
					fieldtypename = QCC_PR_ParseName();
					indextype = QCC_TypeForName(fieldtypename);

					if (!QCC_PR_CheckToken("]"))
					{
						indexname = QCC_PR_ParseName();
						QCC_PR_Expect("]");
					}
				}

				QCC_PR_Expect("=");

				args = 0;
				memset(arg, 0, sizeof(arg));
				strcpy (pr_parm_names[args], "this");
				arg[args].paramname = "this";
				if (isref == 2)
				{
					arg[args].type = newt;
					arg[args].out = 1;	//inout
				}
				else if (isref)
					arg[args].type = QCC_PointerTypeTo(newt);
				else
					arg[args].type = newt;
				args++;
				if (indextype)
				{
					strcpy (pr_parm_names[args], indexname);
					arg[args].paramname = indexname;
					arg[args++].type = indextype;
				}
				if (setnotget)
				{
					strcpy (pr_parm_names[args], "value");
					arg[args].paramname = "value";
					arg[args++].type = fieldtype;
				}
				functype = QCC_PR_GenFunctionType(setnotget?type_void:fieldtype, arg, args);

				if (pr_token_type != tt_name)
				{
					QCC_function_t *f;
					char funcname[256];
					QC_snprintfz(funcname, sizeof(funcname), "%s::%s_%s", newt->name, setnotget?"set":"get", accessorname);

					def = QCC_PR_GetSRef(functype, funcname, NULL, true, 0, GDF_CONST | (isinline?GDF_INLINE:0));

					//pr_classtype = newt;
					f = QCC_PR_ParseImmediateStatements (def.sym, functype, false);
					pr_classtype = NULL;
					pr_scope = NULL;
					def.sym->symboldata[def.ofs].function = f - functions;
					f->def = def.sym;
					def.sym->initialized = 1;
				}
				else
				{
					funcname = QCC_PR_ParseName();
					def = QCC_PR_GetSRef(functype, funcname, NULL, true, 0, GDF_CONST|(isinline?GDF_INLINE:0));
					if (!def.cast)
						QCC_Error(ERR_NOFUNC, "%s::set_%s: %s was not defined", newt->name, accessorname, funcname);
				}
				if (!def.cast || !def.sym || def.sym->temp)
					QCC_Error(ERR_NOFUNC, "%s::%s_%s function invalid", newt->name, setnotget?"set":"get", accessorname);
				
				for (acc = newt->accessors; acc; acc = acc->next)
					if (!strcmp(acc->fieldname, accessorname))
						break;
				if (!acc)
				{
					acc = qccHunkAlloc(sizeof(*acc));
					acc->fieldname = accessorname;
					acc->next = newt->accessors;
					acc->type = fieldtype;
					acc->indexertype = indextype;
					newt->accessors = acc;
				}

				if (acc->getset_func[setnotget].cast)
					QCC_Error(ERR_TOOMANYINITIALISERS, "%s::%s_%s already declared", newt->name, setnotget?"set":"get", accessorname);
				acc->getset_func[setnotget] = def;
				acc->getset_isref[setnotget] = isref;
				QCC_FreeTemp(def);
			} while (QCC_PR_CheckToken(",") || QCC_PR_CheckToken(";"));
			QCC_PR_Expect("}");
		}

		if (newtype)
			newt = QCC_PR_DuplicateType(newt, false);
		return newt;
	}

	if (QCC_PR_CheckKeyword (keyword_class, "class"))
	{
//		int parms;
		QCC_type_t *fieldtype;
		char membername[2048];
		char *classname;
		int forwarddeclaration;
		int numparms = 0;
		struct QCC_typeparam_s *parms = NULL;
		char *parmname;
		int arraysize;
		pbool redeclaration;
		int basicindex;
		QCC_def_t *d;
		QCC_type_t *pc;
		pbool found = false;
		int assumevirtual = 0;	//0=erk, 1=yes, -1=no

		parmname = QCC_PR_ParseName();
		classname = qccHunkAlloc(strlen(parmname)+1);
		strcpy(classname, parmname);

		newt = 0;

		if (QCC_PR_CheckToken(":"))
		{
			char *parentname = QCC_PR_ParseName();
			fieldtype = QCC_TypeForName(parentname);
			if (!fieldtype)
				QCC_PR_ParseError(ERR_NOTANAME, "Parent class %s was not yet defined", parentname);
			forwarddeclaration = false;

			QCC_PR_Expect("{");
		}
		else
		{
			fieldtype = type_entity;
			forwarddeclaration = !QCC_PR_CheckToken("{");
		}

		newt = QCC_TypeForName(classname);
		if (newt && newt->num_parms != 0)
			redeclaration = true;
		else
			redeclaration = false;

		if (!newt)
		{
			newt = QCC_PR_NewType(classname, ev_entity, true);
			newt->size=type_entity->size;
		}

		type = NULL;

		if (forwarddeclaration)
			return newt;

		if (pr_scope)
			QCC_PR_ParseError(ERR_REDECLARATION, "Declaration of class %s%s%s within function", col_type,classname,col_none);
		if (redeclaration && fieldtype != newt->parentclass)
			QCC_PR_ParseError(ERR_REDECLARATION, "Parent class changed on redeclaration of %s%s%s", col_type,classname,col_none);
		newt->parentclass = fieldtype;

		if (QCC_PR_CheckToken(","))
			QCC_PR_ParseError(ERR_NOTANAME, "member missing name");
		while (!QCC_PR_CheckToken("}"))
		{
			pbool havebody = false;
			pbool isnull = false;
			pbool isvirt = false;
			pbool isnonvirt = false;
			pbool isstatic = false;
			pbool isignored = false;
//			pbool ispublic = false;
//			pbool isprivate = false;
//			pbool isprotected = false;
			while(1)
			{
				if (QCC_PR_CheckKeyword(1, "nonvirtual"))
					isnonvirt = true;
				else if (QCC_PR_CheckKeyword(1, "static"))
					isstatic = true;
				else if (QCC_PR_CheckKeyword(1, "virtual"))
					isvirt = true;
				else if (QCC_PR_CheckKeyword(1, "ignore"))
					isignored = true;
				else if (QCC_PR_CheckKeyword(1, "strip"))
					isignored = true;
				else if (QCC_PR_CheckKeyword(1, "public"))
					/*ispublic = true*/;
				else if (QCC_PR_CheckKeyword(1, "private"))
					/*isprivate = true*/;
				else if (QCC_PR_CheckKeyword(1, "protected"))
					/*isprotected = true*/;
				else
					break;
			}
			if (QCC_PR_CheckToken(":"))
			{
				if (isvirt && !isnonvirt)
					assumevirtual = 1;
				else if (isnonvirt && !isvirt)
					assumevirtual = -1;
				continue;
			}
			newparm = QCC_PR_ParseType(false, false);

			if (!newparm)
				QCC_PR_ParseError(ERR_INTERNAL, "In class %s, expected type, found %s", classname, pr_token);

			if (newparm->type == ev_struct || newparm->type == ev_union)	//we wouldn't be able to handle it.
				QCC_PR_ParseError(ERR_INTERNAL, "Struct or union in class %s", classname);

			parmname = QCC_PR_ParseName();
			if (QCC_PR_CheckToken("["))
			{
				arraysize = QCC_PR_IntConstExpr();
				QCC_PR_Expect("]");
			}
			else
				arraysize = 0;

			if (newparm->type == ev_function)
			{
				if (isstatic)
				{
					isstatic = false;
					isnonvirt = true;
//					QCC_PR_ParseError(ERR_INTERNAL, "%s::%s static member functions are not supported at this time.", classname, parmname);
				}

				if (!strcmp(classname, parmname))
				{
					if (isstatic)
						QCC_PR_ParseError(ERR_INTERNAL, "Constructor %s::%s may not be static.", classname, pr_token);
					if (!isvirt)
						isnonvirt = true;//silently promote constructors to static
				}
				else if (!isvirt && !isnonvirt && !isstatic)
				{
					if (assumevirtual == 1)
						isvirt = true;
					else if (assumevirtual == -1)
						isnonvirt = true;
					else
						QCC_PR_ParseWarning(WARN_MISSINGMEMBERQUALIFIER, "%s::%s was not qualified. Assuming non-virtual.", classname, parmname);
				}
				if (isvirt+isnonvirt+isstatic != 1)
					QCC_PR_ParseError(ERR_INTERNAL, "Multiple conflicting qualifiers on %s::%s.", classname, pr_token);
			}
			else
			{
				if (isvirt||isnonvirt)
					QCC_Error(ERR_INTERNAL, "virtual keyword on member that is not a function");
			}

			if (newparm->type == ev_function)
			{
				if (QCC_PR_CheckToken("="))
				{
					havebody = true;
				}
				else if (pr_token[0] == '{')
					havebody = true;
			}

			if (havebody)
			{
				QCC_def_t *def;
				if (pr_scope)
					QCC_Error(ERR_INTERNAL, "Nested function declaration");

				isnull = (QCC_PR_CheckImmediate("0") || QCC_PR_CheckImmediate("0i"));
				QC_snprintfz(membername, sizeof(membername), "%s::%s", classname, parmname);
				if (isnull)
				{
					if (isignored)
						def = NULL;
					else
					{
						def = QCC_PR_GetDef(newparm, membername, NULL, true, 0, 0);
						def->symboldata[def->ofs].function = 0;
						def->initialized = 1;
					}
				}
				else
				{
					if (isignored)
						def = NULL;
					else
						def = QCC_PR_GetDef(newparm, membername, NULL, true, 0, GDF_CONST);

					if (newparm->type != ev_function)
						QCC_Error(ERR_INTERNAL, "Can only initialise member functions");
					else
					{
						if (autoprototype || isignored)
						{
							if (QCC_PR_CheckToken("["))
							{
								while (!QCC_PR_CheckToken("]"))
								{
									if (pr_token_type == tt_eof)
										break;
									QCC_PR_Lex();
								}
							}
							QCC_PR_Expect("{");

							{
								int blev = 1;
								//balance out the { and }
								while(blev)
								{
									if (pr_token_type == tt_eof)
										break;
									if (QCC_PR_CheckToken("{"))
										blev++;
									else if (QCC_PR_CheckToken("}"))
										blev--;
									else
										QCC_PR_Lex();	//ignore it.
								}
							}
						}
						else
						{
							pr_classtype = newt;
							QCC_PR_ParseInitializerDef(def, 0);
							pr_classtype = NULL;
							/*
							f = QCC_PR_ParseImmediateStatements (def, newparm);
							pr_classtype = NULL;
							pr_scope = NULL;
							def->symboldata[def->ofs].function = f - functions;
							f->def = def;
							def->initialized = 1;*/
						}
					}
				}
				if (def)
					QCC_FreeDef(def);

				if (!isvirt && !isignored)
				{
					QCC_def_t *fdef;
					QCC_type_t *pc;
					unsigned int i;

					for (pc = newt->parentclass; pc; pc = pc->parentclass)
					{
						for (i = 0; i < pc->num_parms; i++)
						{
							if (!strcmp(pc->params[i].paramname, parmname))
							{
								QCC_PR_ParseWarning(WARN_DUPLICATEDEFINITION, "%s::%s is virtual inside parent class '%s'. Did you forget the 'virtual' keyword?", newt->name, parmname, pc->name);
								break;
							}
						}
						if (i < pc->num_parms)
							break;
					}
					if (!pc)
					{
						fdef = QCC_PR_GetDef(NULL, parmname, NULL, false, 0, GDF_CONST);
						if (fdef && fdef->type->type == ev_field)
						{
							QCC_PR_ParseWarning(WARN_DUPLICATEDEFINITION, "%s::%s is virtual inside parent class 'entity'. Did you forget the 'virtual' keyword?", newt->name, parmname);
							QCC_PR_ParsePrintDef(0, fdef);
						}
						else if (fdef)
						{
							QCC_PR_ParseWarning(WARN_DUPLICATEDEFINITION, "%s::%s shadows a global", newt->name, parmname);
							QCC_PR_ParsePrintDef(0, fdef);
						}
						if (fdef)
							QCC_FreeDef(fdef);
					}
				}
			}

			QCC_PR_Expect(";");

			if (isignored)	//member doesn't really exist
				continue;

			//static members are technically just funny-named globals, and do not generate fields.
			if (isnonvirt || isstatic || (newparm->type == ev_function && !arraysize))
			{
				unsigned int fl = 0;
				if (newparm->type == ev_function && !arraysize)
					fl = GDF_CONST;

				QC_snprintfz(membername, sizeof(membername), "%s::%s", classname, parmname);
				QCC_FreeDef(QCC_PR_GetDef(newparm, membername, NULL, true, 0, fl));

				if (isnonvirt || isstatic)
					continue;
			}

			
			fieldtype = QCC_PR_NewType(parmname, ev_field, false);
			fieldtype->aux_type = newparm;
			fieldtype->size = newparm->size;

			parms = realloc(parms, sizeof(*parms) * (numparms+1));
			parms[numparms].ofs = 0;
			parms[numparms].out = false;
			parms[numparms].optional = false;
			parms[numparms].isvirtual = isvirt;
			parms[numparms].paramname = parmname;
			parms[numparms].arraysize = arraysize;
			parms[numparms].type = newparm;
			parms[numparms].defltvalue.cast = NULL;

			basicindex = 0;
			found = false;
			for(pc = newt; pc && !found; pc = pc->parentclass)
			{
				struct QCC_typeparam_s *pp;
				int numpc;
				int i;
				if (pc == newt)
				{
					pp = parms;
					numpc = numparms;
				}
				else
				{
					pp = pc->params;
					numpc = pc->num_parms;
				}
				for (i = 0; i < numpc; i++)
				{
					if (pp[i].type->type == newparm->type)
					{
						if (!strcmp(pp[i].paramname, parmname))
						{
							if (typecmp(pp[i].type, newparm))
							{
								char bufc[256];
								char bufp[256];
								TypeName(pp[i].type, bufp, sizeof(bufp));
								TypeName(newparm, bufc, sizeof(bufc));
								QCC_PR_ParseError(0, "%s defined as %s in %s, but %s in %s\n", parmname, bufc, newt->name, bufp, pc->name);
							}
							basicindex = pp[i].ofs;
							found = true;
							break;
						}
						if ((unsigned int)basicindex < pp[i].ofs+pp[i].type->size*(pp[i].arraysize?pp[i].arraysize:1))	//if we found one with the index
							basicindex = pp[i].ofs+pp[i].type->size*(pp[i].arraysize?pp[i].arraysize:1);	//make sure we don't union it.
					}
				}
			}
			parms[numparms].ofs = basicindex;	//ulp, its new
			numparms++;

			if (found)
				continue;

			if (!*basictypes[newparm->type])
				QCC_PR_ParseError(0, "members of type %s are not supported (%s::%s)\n", basictypenames[newparm->type], classname, parmname);

			//make sure the union is okay
			d = QCC_PR_GetDef(NULL, parmname, NULL, 0, 0, GDF_CONST);
			if (d)
				basicindex = 0;
			else
			{	//don't go all weird with unioning generic fields
				QC_snprintfz(membername, sizeof(membername), "::*%s", basictypenames[newparm->type]);
				d = QCC_PR_GetDef(NULL, membername, NULL, 0, 0, GDF_CONST);
				if (!d)
				{
					d = QCC_PR_GetDef(QCC_PR_FieldType(*basictypes[newparm->type]), membername, NULL, 2, 0, GDF_CONST|GDF_POSTINIT|GDF_USED);
//					for (i = 0; (unsigned int)i < newparm->size*(arraysize?arraysize:1); i++)
//						d->symboldata[i]._int = pr.size_fields+i;
//					pr.size_fields += i;

					d->used = true;
					d->referenced = true;	//always referenced, so you can inherit safely.
				}
				if (d->arraysize < basicindex+(arraysize?arraysize:1))
				{
					if (d->symboldata)
						QCC_PR_ParseError(ERR_INTERNAL, "array members are kinda limited, sorry. try rearranging them or adding padding for alignment\n");	//FIXME: add relocs to cope with this all of a type can then be contiguous and thus allow arrays.
					else
					{
						int newsize = basicindex+(arraysize?arraysize:1);
						if (d->type->type == ev_union || d->type->type == ev_struct)
							d->arraysize = newsize;
						else while(d->arraysize < newsize)
						{
							QC_snprintfz(membername, sizeof(membername), "::%s[%i]", basictypenames[newparm->type], d->arraysize/d->type->size);
							QCC_PR_DummyDef(d->type, membername, d->scope, 0, d, d->arraysize, true, GDF_CONST);
							d->arraysize+=d->type->size;
						}
					}
				}
			}
			QCC_FreeDef(d);

			//and make sure we can do member::__fname
			//actually, that seems pointless.
			QC_snprintfz(membername, sizeof(membername), "%s::"MEMBERFIELDNAME, classname, parmname);
//			externs->Printf("define %s -> %s\n", membername, d->name);
			d = QCC_PR_DummyDef(fieldtype, membername, pr_scope, arraysize, d, basicindex, true, (isnull?0:GDF_CONST)|(opt_classfields?GDF_STRIP:0));
			d->referenced = true;	//always referenced, so you can inherit safely.
		}

		if (redeclaration)
		{
			int i;
			redeclaration = newt->num_parms != numparms;

			for (i = 0; i < numparms && (unsigned int)i < newt->num_parms; i++)
			{
				if (newt->params[i].arraysize != parms[i].arraysize || typecmp(newt->params[i].type, parms[i].type) || strcmp(newt->params[i].paramname, parms[i].paramname))
				{
					QCC_PR_ParseError(ERR_REDECLARATION, "Incompatible redeclaration of class %s. %s differs.", classname, parms[i].paramname);
					break;
				}
			}
			if (newt->num_parms != numparms)
				QCC_PR_ParseError(ERR_REDECLARATION, "Incompatible redeclaration of class %s.", classname);
		}
		else
		{
			newt->num_parms = numparms;
			newt->params = qccHunkAlloc(sizeof(*type->params) * numparms);
			memcpy(newt->params, parms, sizeof(*type->params) * numparms);
		}
		free(parms);

		{
			QCC_def_t *d;
			//if there's a constructor, make sure the spawnfunc_ function is defined so that its available to maps.
			QC_snprintfz(membername, sizeof(membername), "spawnfunc_%s", classname);
			d = QCC_PR_GetDef(type_function, membername, NULL, true, 0, GDF_CONST);
			d->funccalled = true;
			d->referenced = true;
			QCC_FreeDef(d);
		}

		QCC_PR_Expect(";");
		return NULL;
	}

	if (QCC_PR_CheckKeyword(keyword_enum, "enum"))
	{
		return QCC_PR_ParseEnum(false);
	}
	if (QCC_PR_CheckKeyword(keyword_enumflags, "enumflags"))
	{
		return QCC_PR_ParseEnum(true);
	}

	structtype = ev_void;
	if (QCC_PR_CheckKeyword (keyword_union, "union"))
		structtype = ev_union;
	else if (QCC_PR_CheckKeyword (keyword_struct, "struct"))
		structtype = ev_struct;
	if (structtype != ev_void)
	{
		struct QCC_typeparam_s *parms = NULL, *oldparm;
		int numparms = 0;
		int ofs;
		unsigned int arraysize;
		char *parmname;

		pbool isnonvirt = false;
		pbool isstatic = false;
		pbool isvirt = false;

		if (QCC_PR_CheckToken("{"))
		{
			//nameless struct
			newt = QCC_PR_NewType(structtype==ev_union?"<union>":"<struct>", structtype, false);
		}
		else
		{
			QCC_type_t *parenttype;
			char *tname = QCC_PR_ParseName();

			if (structtype == ev_struct && QCC_PR_CheckToken(":"))
			{
				char *parentname = QCC_PR_ParseName();
				parenttype = QCC_TypeForName(parentname);
				if (!parenttype)
					QCC_PR_ParseError(ERR_NOTANAME, "Parent type %s was not yet defined", parentname);
				if (parenttype->type != ev_struct)
					QCC_PR_ParseError(ERR_NOTANAME, "Parent type %s is not a struct", parentname);
			}
			else
				parenttype = NULL;

			newt = QCC_TypeForName(tname);
			if (!newt)
			{
				newt = QCC_PR_NewType(tname, ev_struct, true);
				newt->parentclass = parenttype;
			}
			else if (!newt->size && !newt->parentclass)
				newt->parentclass = parenttype;
			else if (parenttype && newt->parentclass != parenttype)
				QCC_PR_ParseError(ERR_NOTANAME, "Redeclaration of struct with different parent type", tname, parenttype->name);

			if (newt->size)
			{
				if (QCC_PR_CheckToken("{"))
					QCC_PR_ParseError(ERR_NOTANAME, "%s %s is already defined", structtype==ev_union?"union":"struct", newt->name);
				return newt;
			}

			//struct declaration only, not definition.
			if (parenttype)
				QCC_PR_Expect("{");
			else if (!QCC_PR_CheckToken("{"))
				return newt;
		}
		if (newt->parentclass)
			newt->size = newt->parentclass->size;
		else
			newt->size=0;

		type = NULL;

		newparm = NULL;
		for (;;)
		{
			//in qc, functions are assignable references like anything else, so no modifiers means the qc will need to assign to it somewhere.
			//virtual functions are still references, but we initialise them somewhere
			//nonvirtual functions and static functions are kinda the same thing
			QCC_sref_t defaultval;
			if (QCC_PR_CheckToken("}"))
			{
				if (newparm)
					QCC_PR_ParseError(ERR_EXPECTED, "missing semi-colon");
				break;
			}
			else if (QCC_PR_CheckToken(";"))
			{
				newparm = NULL;
				continue;
			}
			else if (QCC_PR_CheckToken(","))
			{	//same as last type, unless initial/after-semicolon
				if (!newparm)
					QCC_PR_ParseError(ERR_EXPECTED, "element missing type");
			}
			else
			{	//new type!
				if (newparm)
					QCC_PR_ParseError(ERR_EXPECTED, "missing semi-colon");	//allow a missing semi-colon on functions, for mixed-style functions.

				//reset these...
				isnonvirt = false;
				isstatic = false;
				isvirt = false;

				//parse field modifiers
				if (QCC_PR_CheckKeyword(1, "public"))
					/*ispublic = true*/;
				else if (QCC_PR_CheckKeyword(1, "private"))
					/*isprivate = true*/;
				else if (QCC_PR_CheckKeyword(1, "protected"))
					/*isprotected = true*/;

				if (QCC_PR_CheckKeyword(1, "nonvirtual"))
					isnonvirt = true;
				else if (QCC_PR_CheckKeyword(1, "static"))
					isstatic = true;
				else if (QCC_PR_CheckKeyword(1, "virtual"))
					isvirt = true;
//				else if (QCC_PR_CheckKeyword(1, "ignore"))
//					isignored = true;
//				else if (QCC_PR_CheckKeyword(1, "strip"))
//					isignored = true;

				//now parse the actual type.
				newparm = QCC_PR_ParseType(false, false);
			}
			type = newparm;

			while (QCC_PR_CheckToken("*"))
				type = QCC_PointerTypeTo(type);

			arraysize = 0;
			if (QCC_PR_CheckToken(";"))
			{	//annonymous structs do weird scope stuff.
				newparm = NULL;
				parmname = "";
			}
			else
			{
				parmname = qccHunkAlloc(strlen(pr_token)+1);
				strcpy(parmname, pr_token);
				QCC_PR_Lex();
				if (QCC_PR_CheckToken("["))
				{
					arraysize=QCC_PR_IntConstExpr();
					if (!arraysize)
						QCC_PR_ParseError(ERR_NOTANAME, "cannot cope with 0-sized arrays");
					QCC_PR_Expect("]");
				}
				while (QCC_PR_CheckToken("["))
				{
					int nsize=QCC_PR_IntConstExpr();
					if (!nsize)
						QCC_PR_ParseError(ERR_NOTANAME, "cannot cope with 0-sized arrays");
					QCC_PR_Expect("]");
					arraysize *= nsize;
					QCC_PR_ParseWarning(WARN_IGNOREDKEYWORD, "multi-dimensional arrays are not supported. flattening to single array.");
				}

				if (QCC_PR_CheckToken("("))
					type = QCC_PR_ParseFunctionType(false, type);
			}

			if (type == newt || ((type->type == ev_struct || type->type == ev_union) && !type->size))
			{
				QCC_PR_ParseWarning(ERR_NOTANAME, "type %s not fully defined yet", type->name);
				continue;
			}

			if (QCC_PR_CheckToken(":"))
			{
				QCC_PR_IntConstExpr();
				QCC_PR_ParseWarning(WARN_IGNOREDKEYWORD, "bitfields are not supported");
			}

			if ((isnonvirt || isvirt) && type->type != ev_function)
				QCC_PR_ParseWarning(ERR_INTERNAL, "[non]virtual members must be functions", type->name);

			//static members are technically just funny-named globals, and do not generate fields.
			if (isnonvirt || isstatic || isvirt)
			{	//either way its a regular global. the difference being static has no implicit this/self argument.
				QCC_def_t *d;
				char membername[2048];
				if (!isstatic)
					type = QCC_PR_MakeThiscall(type, newt);

				QC_snprintfz(membername, sizeof(membername), "%s::%s", newt->name, parmname);
				d = QCC_PR_GetDef(type, membername, NULL, true, 0, (type->type==ev_function)?GDF_CONST:0);
				if (QCC_PR_CheckToken("=") || (type->type == ev_function && QCC_PR_PeekToken("{")))
				{
//FIXME: methods cannot be compiled yet, as none of the fields are not actually defined yet.
					pr_classtype = newt;
					QCC_PR_ParseInitializerDef(d, 0);
					pr_classtype = NULL;
				}
				QCC_FreeDef(d);
				if (!QCC_PR_PeekToken(","))
					newparm = NULL;

				if (isvirt)
				{
					defaultval.ofs = 0;
					defaultval.cast = d->type;
					defaultval.sym = d;
				}
				else
					continue;
			}
			else
			{
				defaultval.cast = NULL;
				if (QCC_PR_CheckToken("="))
				{
					defaultval = QCC_PR_ParseDefaultInitialiser(type);
					QCC_PR_ParseWarning(ERR_INTERNAL, "TODO: pre-initialised struct members are not implemented yet", type->name);
				}
			}

			parms = realloc(parms, sizeof(*parms) * (numparms+4));
			oldparm = QCC_PR_FindStructMember(newt, parmname, &ofs);
			if (oldparm && oldparm->arraysize == arraysize && !typecmp_lax(oldparm->type, type))
			{
				if (!isvirt)
					continue;
			}
			else if (structtype == ev_union)
			{
				ofs = 0;
				if (type->size*(arraysize?arraysize:1) > newt->size)
					newt->size = type->size*(arraysize?arraysize:1);
			}
			else
			{
				ofs = newt->size;
				newt->size += type->size*(arraysize?arraysize:1);
			}

			parms[numparms].ofs = ofs;
			parms[numparms].arraysize = arraysize;
			parms[numparms].out = false;
			parms[numparms].optional = false;
			parms[numparms].isvirtual = isvirt;
			parms[numparms].paramname = parmname;
			parms[numparms].type = type;
			parms[numparms].defltvalue = defaultval;
			numparms++;

			/*if (type->type == ev_vector && arraysize == 0)
			{	//add in vec_x/y/z members too.
				int c;
				for (c = 0; c < 3; c++)
				{
					parms[numparms].ofs = ofs + c;
					parms[numparms].arraysize = arraysize;
					parms[numparms].out = false;
					parms[numparms].optional = true;
					parms[numparms].isvirtual = isvirt;
					parms[numparms].paramname = qccHunkAlloc(strlen(parmname)+3);
					sprintf(parms[numparms].paramname, "%s_%c", parmname, 'x'+c);
					parms[numparms].type = type_float;
					parms[numparms].defltvalue = nullsref;
					numparms++;
				}
			}*/
		}
		if (!numparms)
			QCC_PR_ParseError(ERR_NOTANAME, "%s %s has no members", structtype==ev_union?"union":"struct", newt->name);

		newt->num_parms = numparms;
		newt->params = qccHunkAlloc(sizeof(*type->params) * numparms);
		memcpy(newt->params, parms, sizeof(*type->params) * numparms);
		free(parms);

		return newt;
	}

	type = QCC_TypeForName(name);
	if (!type)
	{
		if (!*name)
		{
			QCC_PR_ParseError(ERR_NOTANAME, "type missing name");
			return NULL;
		}

		//some reacc types...
		if (flag_acc && !stricmp("Void", name))
			type = type_void;
		else if (flag_acc && !stricmp("Real", name))
			type = type_float;
		else if (flag_acc && !stricmp("Vector", name))
			type = type_vector;
		else if (flag_acc && !stricmp("Object", name))
			type = type_entity;
		else if (flag_acc && !stricmp("String", name))
			type = type_string;
		else if (flag_acc && !stricmp("PFunc", name))
			type = type_function;
		else
		{
			//try and handle C's types, which have weird and obtuse combinations (like long long, long int, short int).
			pbool isokay = false;
			pbool issigned = false;
			pbool isunsigned = false;
			pbool islong = false;
			pbool isfloat = false;
			int bits = 0;

			while(true)
			{
				if (!isunsigned && !issigned && QCC_PR_CheckKeyword(keyword_signed, "signed"))
					issigned = isokay = true;
				else if (!issigned && !isunsigned && QCC_PR_CheckKeyword(keyword_unsigned, "unsigned"))
					isunsigned = isokay = true;
				else if (!bits && QCC_PR_CheckKeyword(keyword_long, "long"))
				{
					if (islong)
						bits = 128;
					islong = isokay = true;
				}
				else if ((!bits || bits==16) && (QCC_PR_CheckKeyword(keyword_int, "int") || QCC_PR_CheckKeyword(keyword_integer, "integer")))
				{	//long int, short int, etc are allowed
					if (!bits)
						bits = 32;
					isokay = true;
				}
				else if (!bits && QCC_PR_CheckKeyword(keyword_short, "short"))
					bits = 16, isokay = true;
				else if (!bits && QCC_PR_CheckKeyword(keyword_char, "char"))
					bits = 8, isokay = true;
				else if (!bits && QCC_PR_CheckKeyword(keyword_int, "_Bool"))	//c99
					bits = 1, isokay = true;

				else if (!bits && !islong && QCC_PR_CheckKeyword(keyword_float, "float"))
					bits = 32, isfloat = isokay = true;
				else if ((!bits||islong) && QCC_PR_CheckKeyword(keyword_double, "double"))
					bits = islong?128:64, islong=false, isfloat = isokay = true;
				else
					break;
			}
			if (isokay)
			{
				if (!bits)
					bits = islong?64:32;	//<signed|unsigned|long> [int]
				if (isfloat)
				{
					if (isunsigned)
						QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "ignoring unsupported unsigned keyword, type will be signed");
					if (bits > 64)
						type = type_double, QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "long doubles are not supported, using double");	//permitted
					else if (bits == 64)
						type = type_double;
					else
						type = type_float;
				}
				else
				{
					if (bits > 64)
						type = (isunsigned?type_uint64:type_int64), QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "long longs are not supported, using long");	//permitted
					else if (bits == 64)
						type = (isunsigned?type_uint64:type_int64);
					else if (bits == 16)
						type = (isunsigned?type_uint:type_integer), QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "shorts are not supported, using int");	//permitted
					else if (bits == 8)
						type = (isunsigned?type_uint:type_integer), QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "chars are not supported, using int");	//permitted
					else
						type = (isunsigned?type_uint:type_integer);
				}
				goto wasctype;
			}


			if (silentfail)
				return NULL;

			QCC_PR_ParseError (ERR_NOTATYPE, "\"%s\" is not a type", name);
			type = type_float;	// shut up compiler warning
		}
	}
	QCC_PR_Lex ();
wasctype:

	while (QCC_PR_CheckToken("*"))
	{
		if (QCC_PR_CheckKeyword(keyword_const, "const"))
			QCC_PR_ParseWarning (WARN_IGNOREDKEYWORD, "ignoring unsupported const keyword");
		type = QCC_PointerTypeTo(type);
	}

	if (flag_qcfuncs && QCC_PR_CheckToken ("("))	//this is followed by parameters. Must be a function.
	{
		type_inlinefunction = true;
		type = QCC_PR_ParseFunctionType(newtype, type);
	}
	else
	{
		if (newtype)
		{
			type = QCC_PR_DuplicateType(type, false);
		}
	}
	return type;
}

#endif