l_precomp.c

Go to the documentation of this file.

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

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//

/*****************************************************************************
 * name:        l_precomp.c
 *
 * desc:        pre compiler
 *
 * $Archive: /MissionPack/code/botlib/l_precomp.c $
 *
 *****************************************************************************/

//Notes:            fix: PC_StringizeTokens

//#define SCREWUP
//#define BOTLIB
//#define QUAKE
//#define QUAKEC
//#define MEQCC

#ifdef SCREWUP
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>
#include "l_memory.h"
#include "l_script.h"
#include "l_precomp.h"

typedef enum {qfalse, qtrue}    qboolean;
#endif //SCREWUP

#ifdef BOTLIB
#include "../game/q_shared.h"
#include "../game/botlib.h"
#include "be_interface.h"
#include "l_memory.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_log.h"
#endif //BOTLIB

#ifdef MEQCC
#include "qcc.h"
#include "time.h"   //time & ctime
#include "math.h"   //fabs
#include "l_memory.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_log.h"

#define qtrue   true
#define qfalse  false
#endif //MEQCC

#ifdef BSPC
//include files for usage in the BSP Converter
#include "../bspc/qbsp.h"
#include "../bspc/l_log.h"
#include "../bspc/l_mem.h"
#include "l_precomp.h"

#define qtrue   true
#define qfalse  false
#define Q_stricmp   stricmp

#endif //BSPC

#if defined(QUAKE) && !defined(BSPC)
#include "l_utils.h"
#endif //QUAKE

//#define DEBUG_EVAL

#define MAX_DEFINEPARMS         128

#define DEFINEHASHING           1

//directive name with parse function
typedef struct directive_s
{
    char *name;
    int (*func)(source_t *source);
} directive_t;

#define DEFINEHASHSIZE      1024

#define TOKEN_HEAP_SIZE     4096

int numtokens;
/*
int tokenheapinitialized;               //true when the token heap is initialized
token_t token_heap[TOKEN_HEAP_SIZE];    //heap with tokens
token_t *freetokens;                    //free tokens from the heap
*/

//list with global defines added to every source loaded
define_t *globaldefines;

//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void QDECL SourceError(source_t *source, char *str, ...)
{
    char text[1024];
    va_list ap;

    va_start(ap, str);
    vsprintf(text, str, ap);
    va_end(ap);
#ifdef BOTLIB
    botimport.Print(PRT_ERROR, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif  //BOTLIB
#ifdef MEQCC
    printf("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif //MEQCC
#ifdef BSPC
    Log_Print("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif //BSPC
} //end of the function SourceError
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void QDECL SourceWarning(source_t *source, char *str, ...)
{
    char text[1024];
    va_list ap;

    va_start(ap, str);
    vsprintf(text, str, ap);
    va_end(ap);
#ifdef BOTLIB
    botimport.Print(PRT_WARNING, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif //BOTLIB
#ifdef MEQCC
    printf("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif //MEQCC
#ifdef BSPC
    Log_Print("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
#endif //BSPC
} //end of the function ScriptWarning
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_PushIndent(source_t *source, int type, int skip)
{
    indent_t *indent;

    indent = (indent_t *) GetMemory(sizeof(indent_t));
    indent->type = type;
    indent->script = source->scriptstack;
    indent->skip = (skip != 0);
    source->skip += indent->skip;
    indent->next = source->indentstack;
    source->indentstack = indent;
} //end of the function PC_PushIndent
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_PopIndent(source_t *source, int *type, int *skip)
{
    indent_t *indent;

    *type = 0;
    *skip = 0;

    indent = source->indentstack;
    if (!indent) return;

    //must be an indent from the current script
    if (source->indentstack->script != source->scriptstack) return;

    *type = indent->type;
    *skip = indent->skip;
    source->indentstack = source->indentstack->next;
    source->skip -= indent->skip;
    FreeMemory(indent);
} //end of the function PC_PopIndent
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_PushScript(source_t *source, script_t *script)
{
    script_t *s;

    for (s = source->scriptstack; s; s = s->next)
    {
        if (!Q_stricmp(s->filename, script->filename))
        {
            SourceError(source, "%s recursively included", script->filename);
            return;
        } //end if
    } //end for
    //push the script on the script stack
    script->next = source->scriptstack;
    source->scriptstack = script;
} //end of the function PC_PushScript
//============================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//============================================================================
void PC_InitTokenHeap(void)
{
    /*
    int i;

    if (tokenheapinitialized) return;
    freetokens = NULL;
    for (i = 0; i < TOKEN_HEAP_SIZE; i++)
    {
        token_heap[i].next = freetokens;
        freetokens = &token_heap[i];
    } //end for
    tokenheapinitialized = qtrue;
    */
} //end of the function PC_InitTokenHeap
//============================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//============================================================================
token_t *PC_CopyToken(token_t *token)
{
    token_t *t;

//  t = (token_t *) malloc(sizeof(token_t));
    t = (token_t *) GetMemory(sizeof(token_t));
//  t = freetokens;
    if (!t)
    {
#ifdef BSPC
        Error("out of token space\n");
#else
        Com_Error(ERR_FATAL, "out of token space\n");
#endif
        return NULL;
    } //end if
//  freetokens = freetokens->next;
    Com_Memcpy(t, token, sizeof(token_t));
    t->next = NULL;
    numtokens++;
    return t;
} //end of the function PC_CopyToken
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_FreeToken(token_t *token)
{
    //free(token);
    FreeMemory(token);
//  token->next = freetokens;
//  freetokens = token;
    numtokens--;
} //end of the function PC_FreeToken
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ReadSourceToken(source_t *source, token_t *token)
{
    token_t *t;
    script_t *script;
    int type, skip;

    //if there's no token already available
    while(!source->tokens)
    {
        //if there's a token to read from the script
        if (PS_ReadToken(source->scriptstack, token)) return qtrue;
        //if at the end of the script
        if (EndOfScript(source->scriptstack))
        {
            //remove all indents of the script
            while(source->indentstack &&
                    source->indentstack->script == source->scriptstack)
            {
                SourceWarning(source, "missing #endif");
                PC_PopIndent(source, &type, &skip);
            } //end if
        } //end if
        //if this was the initial script
        if (!source->scriptstack->next) return qfalse;
        //remove the script and return to the last one
        script = source->scriptstack;
        source->scriptstack = source->scriptstack->next;
        FreeScript(script);
    } //end while
    //copy the already available token
    Com_Memcpy(token, source->tokens, sizeof(token_t));
    //free the read token
    t = source->tokens;
    source->tokens = source->tokens->next;
    PC_FreeToken(t);
    return qtrue;
} //end of the function PC_ReadSourceToken
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_UnreadSourceToken(source_t *source, token_t *token)
{
    token_t *t;

    t = PC_CopyToken(token);
    t->next = source->tokens;
    source->tokens = t;
    return qtrue;
} //end of the function PC_UnreadSourceToken
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ReadDefineParms(source_t *source, define_t *define, token_t **parms, int maxparms)
{
    token_t token, *t, *last;
    int i, done, lastcomma, numparms, indent;

    if (!PC_ReadSourceToken(source, &token))
    {
        SourceError(source, "define %s missing parms", define->name);
        return qfalse;
    } //end if
    //
    if (define->numparms > maxparms)
    {
        SourceError(source, "define with more than %d parameters", maxparms);
        return qfalse;
    } //end if
    //
    for (i = 0; i < define->numparms; i++) parms[i] = NULL;
    //if no leading "("
    if (strcmp(token.string, "("))
    {
        PC_UnreadSourceToken(source, &token);
        SourceError(source, "define %s missing parms", define->name);
        return qfalse;
    } //end if
    //read the define parameters
    for (done = 0, numparms = 0, indent = 0; !done;)
    {
        if (numparms >= maxparms)
        {
            SourceError(source, "define %s with too many parms", define->name);
            return qfalse;
        } //end if
        if (numparms >= define->numparms)
        {
            SourceWarning(source, "define %s has too many parms", define->name);
            return qfalse;
        } //end if
        parms[numparms] = NULL;
        lastcomma = 1;
        last = NULL;
        while(!done)
        {
            //
            if (!PC_ReadSourceToken(source, &token))
            {
                SourceError(source, "define %s incomplete", define->name);
                return qfalse;
            } //end if
            //
            if (!strcmp(token.string, ","))
            {
                if (indent <= 0)
                {
                    if (lastcomma) SourceWarning(source, "too many comma's");
                    lastcomma = 1;
                    break;
                } //end if
            } //end if
            lastcomma = 0;
            //
            if (!strcmp(token.string, "("))
            {
                indent++;
                continue;
            } //end if
            else if (!strcmp(token.string, ")"))
            {
                if (--indent <= 0)
                {
                    if (!parms[define->numparms-1])
                    {
                        SourceWarning(source, "too few define parms");
                    } //end if
                    done = 1;
                    break;
                } //end if
            } //end if
            //
            if (numparms < define->numparms)
            {
                //
                t = PC_CopyToken(&token);
                t->next = NULL;
                if (last) last->next = t;
                else parms[numparms] = t;
                last = t;
            } //end if
        } //end while
        numparms++;
    } //end for
    return qtrue;
} //end of the function PC_ReadDefineParms
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_StringizeTokens(token_t *tokens, token_t *token)
{
    token_t *t;

    token->type = TT_STRING;
    token->whitespace_p = NULL;
    token->endwhitespace_p = NULL;
    token->string[0] = '\0';
    strcat(token->string, "\"");
    for (t = tokens; t; t = t->next)
    {
        strncat(token->string, t->string, MAX_TOKEN - strlen(token->string));
    } //end for
    strncat(token->string, "\"", MAX_TOKEN - strlen(token->string));
    return qtrue;
} //end of the function PC_StringizeTokens
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_MergeTokens(token_t *t1, token_t *t2)
{
    //merging of a name with a name or number
    if (t1->type == TT_NAME && (t2->type == TT_NAME || t2->type == TT_NUMBER))
    {
        strcat(t1->string, t2->string);
        return qtrue;
    } //end if
    //merging of two strings
    if (t1->type == TT_STRING && t2->type == TT_STRING)
    {
        //remove trailing double quote
        t1->string[strlen(t1->string)-1] = '\0';
        //concat without leading double quote
        strcat(t1->string, &t2->string[1]);
        return qtrue;
    } //end if
    //FIXME: merging of two number of the same sub type
    return qfalse;
} //end of the function PC_MergeTokens
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
/*
void PC_PrintDefine(define_t *define)
{
    printf("define->name = %s\n", define->name);
    printf("define->flags = %d\n", define->flags);
    printf("define->builtin = %d\n", define->builtin);
    printf("define->numparms = %d\n", define->numparms);
//  token_t *parms;                 //define parameters
//  token_t *tokens;                    //macro tokens (possibly containing parm tokens)
//  struct define_s *next;          //next defined macro in a list
} //end of the function PC_PrintDefine*/
#if DEFINEHASHING
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_PrintDefineHashTable(define_t **definehash)
{
    int i;
    define_t *d;

    for (i = 0; i < DEFINEHASHSIZE; i++)
    {
        Log_Write("%4d:", i);
        for (d = definehash[i]; d; d = d->hashnext)
        {
            Log_Write(" %s", d->name);
        } //end for
        Log_Write("\n");
    } //end for
} //end of the function PC_PrintDefineHashTable
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
//char primes[16] = {1, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 41, 43, 47};

int PC_NameHash(char *name)
{
    int register hash, i;

    hash = 0;
    for (i = 0; name[i] != '\0'; i++)
    {
        hash += name[i] * (119 + i);
        //hash += (name[i] << 7) + i;
        //hash += (name[i] << (i&15));
    } //end while
    hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (DEFINEHASHSIZE-1);
    return hash;
} //end of the function PC_NameHash
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_AddDefineToHash(define_t *define, define_t **definehash)
{
    int hash;

    hash = PC_NameHash(define->name);
    define->hashnext = definehash[hash];
    definehash[hash] = define;
} //end of the function PC_AddDefineToHash
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
define_t *PC_FindHashedDefine(define_t **definehash, char *name)
{
    define_t *d;
    int hash;

    hash = PC_NameHash(name);
    for (d = definehash[hash]; d; d = d->hashnext)
    {
        if (!strcmp(d->name, name)) return d;
    } //end for
    return NULL;
} //end of the function PC_FindHashedDefine
#endif //DEFINEHASHING
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
define_t *PC_FindDefine(define_t *defines, char *name)
{
    define_t *d;

    for (d = defines; d; d = d->next)
    {
        if (!strcmp(d->name, name)) return d;
    } //end for
    return NULL;
} //end of the function PC_FindDefine
//============================================================================
//
// Parameter:               -
// Returns:                 number of the parm
//                              if no parm found with the given name -1 is returned
// Changes Globals:     -
//============================================================================
int PC_FindDefineParm(define_t *define, char *name)
{
    token_t *p;
    int i;

    i = 0;
    for (p = define->parms; p; p = p->next)
    {
        if (!strcmp(p->string, name)) return i;
        i++;
    } //end for
    return -1;
} //end of the function PC_FindDefineParm
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_FreeDefine(define_t *define)
{
    token_t *t, *next;

    //free the define parameters
    for (t = define->parms; t; t = next)
    {
        next = t->next;
        PC_FreeToken(t);
    } //end for
    //free the define tokens
    for (t = define->tokens; t; t = next)
    {
        next = t->next;
        PC_FreeToken(t);
    } //end for
    //free the define
    FreeMemory(define);
} //end of the function PC_FreeDefine
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_AddBuiltinDefines(source_t *source)
{
    int i;
    define_t *define;
    struct builtin
    {
        char *string;
        int builtin;
    } builtin[] = { // bk001204 - brackets
        { "__LINE__",   BUILTIN_LINE },
        { "__FILE__",   BUILTIN_FILE },
        { "__DATE__",   BUILTIN_DATE },
        { "__TIME__",   BUILTIN_TIME },
//      { "__STDC__", BUILTIN_STDC },
        { NULL, 0 }
    };

    for (i = 0; builtin[i].string; i++)
    {
        define = (define_t *) GetMemory(sizeof(define_t) + strlen(builtin[i].string) + 1);
        Com_Memset(define, 0, sizeof(define_t));
        define->name = (char *) define + sizeof(define_t);
        strcpy(define->name, builtin[i].string);
        define->flags |= DEFINE_FIXED;
        define->builtin = builtin[i].builtin;
        //add the define to the source
#if DEFINEHASHING
        PC_AddDefineToHash(define, source->definehash);
#else
        define->next = source->defines;
        source->defines = define;
#endif //DEFINEHASHING
    } //end for
} //end of the function PC_AddBuiltinDefines
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ExpandBuiltinDefine(source_t *source, token_t *deftoken, define_t *define,
                                        token_t **firsttoken, token_t **lasttoken)
{
    token_t *token;
    unsigned long t;    //  time_t t; //to prevent LCC warning
    char *curtime;

    token = PC_CopyToken(deftoken);
    switch(define->builtin)
    {
        case BUILTIN_LINE:
        {
            sprintf(token->string, "%d", deftoken->line);
#ifdef NUMBERVALUE
            token->intvalue = deftoken->line;
            token->floatvalue = deftoken->line;
#endif //NUMBERVALUE
            token->type = TT_NUMBER;
            token->subtype = TT_DECIMAL | TT_INTEGER;
            *firsttoken = token;
            *lasttoken = token;
            break;
        } //end case
        case BUILTIN_FILE:
        {
            strcpy(token->string, source->scriptstack->filename);
            token->type = TT_NAME;
            token->subtype = strlen(token->string);
            *firsttoken = token;
            *lasttoken = token;
            break;
        } //end case
        case BUILTIN_DATE:
        {
            t = time(NULL);
            curtime = ctime(&t);
            strcpy(token->string, "\"");
            strncat(token->string, curtime+4, 7);
            strncat(token->string+7, curtime+20, 4);
            strcat(token->string, "\"");
            free(curtime);
            token->type = TT_NAME;
            token->subtype = strlen(token->string);
            *firsttoken = token;
            *lasttoken = token;
            break;
        } //end case
        case BUILTIN_TIME:
        {
            t = time(NULL);
            curtime = ctime(&t);
            strcpy(token->string, "\"");
            strncat(token->string, curtime+11, 8);
            strcat(token->string, "\"");
            free(curtime);
            token->type = TT_NAME;
            token->subtype = strlen(token->string);
            *firsttoken = token;
            *lasttoken = token;
            break;
        } //end case
        case BUILTIN_STDC:
        default:
        {
            *firsttoken = NULL;
            *lasttoken = NULL;
            break;
        } //end case
    } //end switch
    return qtrue;
} //end of the function PC_ExpandBuiltinDefine
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ExpandDefine(source_t *source, token_t *deftoken, define_t *define,
                                        token_t **firsttoken, token_t **lasttoken)
{
    token_t *parms[MAX_DEFINEPARMS], *dt, *pt, *t;
    token_t *t1, *t2, *first, *last, *nextpt, token;
    int parmnum, i;

    //if it is a builtin define
    if (define->builtin)
    {
        return PC_ExpandBuiltinDefine(source, deftoken, define, firsttoken, lasttoken);
    } //end if
    //if the define has parameters
    if (define->numparms)
    {
        if (!PC_ReadDefineParms(source, define, parms, MAX_DEFINEPARMS)) return qfalse;
#ifdef DEBUG_EVAL
        for (i = 0; i < define->numparms; i++)
        {
            Log_Write("define parms %d:", i);
            for (pt = parms[i]; pt; pt = pt->next)
            {
                Log_Write("%s", pt->string);
            } //end for
        } //end for
#endif //DEBUG_EVAL
    } //end if
    //empty list at first
    first = NULL;
    last = NULL;
    //create a list with tokens of the expanded define
    for (dt = define->tokens; dt; dt = dt->next)
    {
        parmnum = -1;
        //if the token is a name, it could be a define parameter
        if (dt->type == TT_NAME)
        {
            parmnum = PC_FindDefineParm(define, dt->string);
        } //end if
        //if it is a define parameter
        if (parmnum >= 0)
        {
            for (pt = parms[parmnum]; pt; pt = pt->next)
            {
                t = PC_CopyToken(pt);
                //add the token to the list
                t->next = NULL;
                if (last) last->next = t;
                else first = t;
                last = t;
            } //end for
        } //end if
        else
        {
            //if stringizing operator
            if (dt->string[0] == '#' && dt->string[1] == '\0')
            {
                //the stringizing operator must be followed by a define parameter
                if (dt->next) parmnum = PC_FindDefineParm(define, dt->next->string);
                else parmnum = -1;
                //
                if (parmnum >= 0)
                {
                    //step over the stringizing operator
                    dt = dt->next;
                    //stringize the define parameter tokens
                    if (!PC_StringizeTokens(parms[parmnum], &token))
                    {
                        SourceError(source, "can't stringize tokens");
                        return qfalse;
                    } //end if
                    t = PC_CopyToken(&token);
                } //end if
                else
                {
                    SourceWarning(source, "stringizing operator without define parameter");
                    continue;
                } //end if
            } //end if
            else
            {
                t = PC_CopyToken(dt);
            } //end else
            //add the token to the list
            t->next = NULL;
            if (last) last->next = t;
            else first = t;
            last = t;
        } //end else
    } //end for
    //check for the merging operator
    for (t = first; t; )
    {
        if (t->next)
        {
            //if the merging operator
            if (t->next->string[0] == '#' && t->next->string[1] == '#')
            {
                t1 = t;
                t2 = t->next->next;
                if (t2)
                {
                    if (!PC_MergeTokens(t1, t2))
                    {
                        SourceError(source, "can't merge %s with %s", t1->string, t2->string);
                        return qfalse;
                    } //end if
                    PC_FreeToken(t1->next);
                    t1->next = t2->next;
                    if (t2 == last) last = t1;
                    PC_FreeToken(t2);
                    continue;
                } //end if
            } //end if
        } //end if
        t = t->next;
    } //end for
    //store the first and last token of the list
    *firsttoken = first;
    *lasttoken = last;
    //free all the parameter tokens
    for (i = 0; i < define->numparms; i++)
    {
        for (pt = parms[i]; pt; pt = nextpt)
        {
            nextpt = pt->next;
            PC_FreeToken(pt);
        } //end for
    } //end for
    //
    return qtrue;
} //end of the function PC_ExpandDefine
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ExpandDefineIntoSource(source_t *source, token_t *deftoken, define_t *define)
{
    token_t *firsttoken, *lasttoken;

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

    if (firsttoken && lasttoken)
    {
        lasttoken->next = source->tokens;
        source->tokens = firsttoken;
        return qtrue;
    } //end if
    return qfalse;
} //end of the function PC_ExpandDefineIntoSource
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_ConvertPath(char *path)
{
    char *ptr;

    //remove double path seperators
    for (ptr = path; *ptr;)
    {
        if ((*ptr == '\\' || *ptr == '/') &&
                (*(ptr+1) == '\\' || *(ptr+1) == '/'))
        {
            strcpy(ptr, ptr+1);
        } //end if
        else
        {
            ptr++;
        } //end else
    } //end while
    //set OS dependent path seperators
    for (ptr = path; *ptr;)
    {
        if (*ptr == '/' || *ptr == '\\') *ptr = PATHSEPERATOR_CHAR;
        ptr++;
    } //end while
} //end of the function PC_ConvertPath
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_Directive_include(source_t *source)
{
    script_t *script;
    token_t token;
    char path[MAX_PATH];
#ifdef QUAKE
    foundfile_t file;
#endif //QUAKE

    if (source->skip > 0) return qtrue;
    //
    if (!PC_ReadSourceToken(source, &token))
    {
        SourceError(source, "#include without file name");
        return qfalse;
    } //end if
    if (token.linescrossed > 0)
    {
        SourceError(source, "#include without file name");
        return qfalse;
    } //end if
    if (token.type == TT_STRING)
    {
        StripDoubleQuotes(token.string);
        PC_ConvertPath(token.string);
        script = LoadScriptFile(token.string);
        if (!script)
        {
            strcpy(path, source->includepath);
            strcat(path, token.string);
            script = LoadScriptFile(path);
        } //end if
    } //end if
    else if (token.type == TT_PUNCTUATION && *token.string == '<')
    {
        strcpy(path, source->includepath);
        while(PC_ReadSourceToken(source, &token))
        {
            if (token.linescrossed > 0)
            {
                PC_UnreadSourceToken(source, &token);
                break;
            } //end if
            if (token.type == TT_PUNCTUATION && *token.string == '>') break;
            strncat(path, token.string, MAX_PATH);
        } //end while
        if (*token.string != '>')
        {
            SourceWarning(source, "#include missing trailing >");
        } //end if
        if (!strlen(path))
        {
            SourceError(source, "#include without file name between < >");
            return qfalse;
        } //end if
        PC_ConvertPath(path);
        script = LoadScriptFile(path);
    } //end if
    else
    {
        SourceError(source, "#include without file name");
        return qfalse;
    } //end else
#ifdef QUAKE
    if (!script)
    {
        Com_Memset(&file, 0, sizeof(foundfile_t));
        script = LoadScriptFile(path);
        if (script) strncpy(script->filename, path, MAX_PATH);
    } //end if
#endif //QUAKE
    if (!script)
    {
#ifdef SCREWUP
        SourceWarning(source, "file %s not found", path);
        return qtrue;
#else
        SourceError(source, "file %s not found", path);
        return qfalse;
#endif //SCREWUP
    } //end if
    PC_PushScript(source, script);
    return qtrue;
} //end of the function PC_Directive_include
//============================================================================
// reads a token from the current line, continues reading on the next
// line only if a backslash '\' is encountered.
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_ReadLine(source_t *source, token_t *token)
{
    int crossline;

    crossline = 0;
    do
    {
        if (!PC_ReadSourceToken(source, token)) return qfalse;
        
        if (token->linescrossed > crossline)
        {
            PC_UnreadSourceToken(source, token);
            return qfalse;
        } //end if
        crossline = 1;
    } while(!strcmp(token->string, "\\"));
    return qtrue;
} //end of the function PC_ReadLine
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_WhiteSpaceBeforeToken(token_t *token)
{
    return token->endwhitespace_p - token->whitespace_p > 0;
} //end of the function PC_WhiteSpaceBeforeToken
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
void PC_ClearTokenWhiteSpace(token_t *token)
{
    token->whitespace_p = NULL;
    token->endwhitespace_p = NULL;
    token->linescrossed = 0;
} //end of the function PC_ClearTokenWhiteSpace
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_Directive_undef(source_t *source)
{
    token_t token;
    define_t *define, *lastdefine;
    int hash;

    if (source->skip > 0) return qtrue;
    //
    if (!PC_ReadLine(source, &token))
    {
        SourceError(source, "undef without name");
        return qfalse;
    } //end if
    if (token.type != TT_NAME)
    {
        PC_UnreadSourceToken(source, &token);
        SourceError(source, "expected name, found %s", token.string);
        return qfalse;
    } //end if
#if DEFINEHASHING

    hash = PC_NameHash(token.string);
    for (lastdefine = NULL, define = source->definehash[hash]; define; define = define->hashnext)
    {
        if (!strcmp(define->name, token.string))
        {
            if (define->flags & DEFINE_FIXED)
            {
                SourceWarning(source, "can't undef %s", token.string);
            } //end if
            else
            {
                if (lastdefine) lastdefine->hashnext = define->hashnext;
                else source->definehash[hash] = define->hashnext;
                PC_FreeDefine(define);
            } //end else
            break;
        } //end if
        lastdefine = define;
    } //end for
#else //DEFINEHASHING
    for (lastdefine = NULL, define = source->defines; define; define = define->next)
    {
        if (!strcmp(define->name, token.string))
        {
            if (define->flags & DEFINE_FIXED)
            {
                SourceWarning(source, "can't undef %s", token.string);
            } //end if
            else
            {
                if (lastdefine) lastdefine->next = define->next;
                else source->defines = define->next;
                PC_FreeDefine(define);
            } //end else
            break;
        } //end if
        lastdefine = define;
    } //end for
#endif //DEFINEHASHING
    return qtrue;
} //end of the function PC_Directive_undef
//============================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//============================================================================
int PC_Directive_define(source_t *source)
{
    token_t token, *t, *last;
    define_t *define;

    if (source->skip > 0) return qtrue;
    //
    if (!PC_ReadLine(source, &token))
    {
        SourceError(source, "#define without name");
        return qfalse;
    } //end if
    if (token.type != TT_NAME)
    {
        PC_UnreadSourceToken(source, &token);
        SourceError(source, "expected name after #define, found %s", token.string);
        return qfalse;
    } //end if
    //check if the define already exists
#if DEFINEHASHING
    define = PC_FindHashedDefine(source->definehash, token.string);
#else
    define = PC_FindDefine(source->defines, token.string);
#endif //DEFINEHASHING
    if (define)
    {
        if (define->flags & DEFINE_FIXED)
        {
            SourceError(source, "can't redefine %s", token.string);
            return qfalse;
        } //end if
        SourceWarning(source, "redefinition of %s", token.string);
        //unread the define name before executing the #undef directive
        PC_UnreadSourceToken(source, &token);
        if (!PC_Directive_undef(source)) return qfalse;
        //if the define was not removed (define->flags & DEFINE_FIXED)
#if DEFINEHASHING
        define = PC_FindHashedDefine(source->definehash, token.string);
#else
        define = PC_FindDefine(source->defines, token.string);
#endif //DEFINEHASHING
    } //end if
    //allocate define
    define = (define_t *) GetMemory(sizeof(define_t) + strlen(token.string) + 1);
    Com_Memset(define, 0, sizeof(define_t));
    define->name = (char *) define + sizeof(define_t);
    strcpy(define->name, token.string);
    //add the define to the source
#if DEFINEHASHING
    PC_AddDefineToHash(define, source->definehash);
#else //DEFINEHASHING
    define->next = source->defines;
    source->defines = define;
#endif //DEFINEHASHING
    //if nothing is defined, just return
    if (!PC_ReadLine(source, &token)) return qtrue;
    //if it is a define with parameters
    if (!PC_WhiteSpaceBeforeToken(&token) && !strcmp(token.string,