main.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 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 3 of the License, or
(at your option) any later version.

Doom 3 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../idlib/precompiled.h"
#include "../sys/sys_local.h"
#pragma hdrstop

#include "TypeInfoGen.h"

idSession *                     session = NULL;
idDeclManager *         declManager = NULL;
idEventLoop *           eventLoop = NULL;

int idEventLoop::JournalLevel( void ) const { return 0; }

/*
==============================================================

        idCommon

==============================================================
*/

#define STDIO_PRINT( pre, post )        \
        va_list argptr;                                 \
        va_start( argptr, fmt );                \
        printf( pre );                                  \
        vprintf( fmt, argptr );                 \
        printf( post );                                 \
        va_end( argptr )


class idCommonLocal : public idCommon {
public:
                                                        idCommonLocal( void ) {}

        virtual void                    Init( int argc, const char **argv, const char *cmdline ) {}
        virtual void                    Shutdown( void ) {}
        virtual void                    Quit( void ) {}
        virtual bool                    IsInitialized( void ) const { return true; }
        virtual void                    Frame( void ) {}
        virtual void                    GUIFrame( bool execCmd, bool network  ) {}
        virtual void                    Async( void ) {}
        virtual void                    StartupVariable( const char *match, bool once ) {}
        virtual void                    InitTool( const toolFlag_t tool, const idDict *dict ) {}
        virtual void                    ActivateTool( bool active ) {}
        virtual void                    WriteConfigToFile( const char *filename ) {}
        virtual void                    WriteFlaggedCVarsToFile( const char *filename, int flags, const char *setCmd ) {}
        virtual void                    BeginRedirect( char *buffer, int buffersize, void (*flush)( const char * ) ) {}
        virtual void                    EndRedirect( void ) {}
        virtual void                    SetRefreshOnPrint( bool set ) {}
        virtual void                    Printf( const char *fmt, ... ) { STDIO_PRINT( "", "" ); }
        virtual void                    VPrintf( const char *fmt, va_list arg ) { vprintf( fmt, arg ); }
        virtual void                    DPrintf( const char *fmt, ... ) { /*STDIO_PRINT( "", "" );*/ }
        virtual void                    Warning( const char *fmt, ... ) { STDIO_PRINT( "WARNING: ", "\n" ); }
        virtual void                    DWarning( const char *fmt, ...) { /*STDIO_PRINT( "WARNING: ", "\n" );*/ }
        virtual void                    PrintWarnings( void ) {}
        virtual void                    ClearWarnings( const char *reason ) {}
        virtual void                    Error( const char *fmt, ... ) { STDIO_PRINT( "ERROR: ", "\n" ); exit(0); }
        virtual void                    FatalError( const char *fmt, ... ) { STDIO_PRINT( "FATAL ERROR: ", "\n" ); exit(0); }
        virtual const idLangDict *GetLanguageDict() { return NULL; }
        virtual const char *    KeysFromBinding( const char *bind ) { return NULL; }
        virtual const char *    BindingFromKey( const char *key ) { return NULL; }
        virtual int                             ButtonState( int key ) { return 0; }
        virtual int                             KeyState( int key ) { return 0; }
};

idCVar com_developer( "developer", "0", CVAR_BOOL|CVAR_SYSTEM, "developer mode" );

idCommonLocal           commonLocal;
idCommon *                      common = &commonLocal;

/*
==============================================================

        idSys

==============================================================
*/

void                    Sys_Mkdir( const char *path ) {}
ID_TIME_T                       Sys_FileTimeStamp( FILE *fp ) { return 0; }

#ifdef _WIN32

#include <io.h>
#include <direct.h>

const char *Sys_Cwd( void ) {
        static char cwd[1024];

        _getcwd( cwd, sizeof( cwd ) - 1 );
        cwd[sizeof( cwd ) - 1] = 0;

        /*int i = idStr::FindText( cwd, CD_BASEDIR, false );
        if ( i >= 0 ) {
                cwd[i + strlen( CD_BASEDIR )] = '\0';
        }*/

        return cwd;
}

const char *Sys_DefaultCDPath( void ) {
        return "";
}

const char *Sys_DefaultBasePath( void ) {
        return Sys_Cwd();
}

const char *Sys_DefaultSavePath( void ) {
        return cvarSystem->GetCVarString( "fs_basepath" );
}

const char *Sys_EXEPath( void ) {
        return "";
}

int Sys_ListFiles( const char *directory, const char *extension, idStrList &list ) {
        idStr           search;
        struct _finddata_t findinfo;
        int                     findhandle;
        int                     flag;

        if ( !extension) {
                extension = "";
        }

        // passing a slash as extension will find directories
        if ( extension[0] == '/' && extension[1] == 0 ) {
                extension = "";
                flag = 0;
        } else {
                flag = _A_SUBDIR;
        }

        sprintf( search, "%s\\*%s", directory, extension );

        // search
        list.Clear();

        findhandle = _findfirst( search, &findinfo );
        if ( findhandle == -1 ) {
                return -1;
        }

        do {
                if ( flag ^ ( findinfo.attrib & _A_SUBDIR ) ) {
                        list.Append( findinfo.name );
                }
        } while ( _findnext( findhandle, &findinfo ) != -1 );

        _findclose( findhandle );

        return list.Num();
}

#else

const char *    Sys_DefaultCDPath( void ) { return ""; }
const char *    Sys_DefaultBasePath( void ) { return ""; }
const char *    Sys_DefaultSavePath( void ) { return ""; }
int                             Sys_ListFiles( const char *directory, const char *extension, idStrList &list ) { return 0; }

#endif

xthreadInfo *   g_threads[MAX_THREADS];
int                             g_thread_count;

void                    Sys_CreateThread( xthread_t function, void *parms, xthreadPriority priority, xthreadInfo &info, const char *name, xthreadInfo *threads[MAX_THREADS], int *thread_count ) {}
void                    Sys_DestroyThread( xthreadInfo& info ) {}

void                    Sys_EnterCriticalSection( int index ) {}
void                    Sys_LeaveCriticalSection( int index ) {}

void                    Sys_WaitForEvent( int index ) {}
void                    Sys_TriggerEvent( int index ) {}

/*
==============
idSysLocal stub
==============
*/
void                    idSysLocal::DebugPrintf( const char *fmt, ... ) {}
void                    idSysLocal::DebugVPrintf( const char *fmt, va_list arg ) {}

double                  idSysLocal::GetClockTicks( void ) { return 0.0; }
double                  idSysLocal::ClockTicksPerSecond( void ) { return 1.0; }
cpuid_t                 idSysLocal::GetProcessorId( void ) { return (cpuid_t)0; }
const char *    idSysLocal::GetProcessorString( void ) { return ""; }
const char *    idSysLocal::FPU_GetState( void ) { return ""; }
bool                    idSysLocal::FPU_StackIsEmpty( void ) { return true; }
void                    idSysLocal::FPU_SetFTZ( bool enable ) {}
void                    idSysLocal::FPU_SetDAZ( bool enable ) {}

bool                    idSysLocal::LockMemory( void *ptr, int bytes ) { return false; }
bool                    idSysLocal::UnlockMemory( void *ptr, int bytes ) { return false; }

void                    idSysLocal::GetCallStack( address_t *callStack, const int callStackSize ) { memset( callStack, 0, callStackSize * sizeof( callStack[0] ) ); }
const char *    idSysLocal::GetCallStackStr( const address_t *callStack, const int callStackSize ) { return ""; }
const char *    idSysLocal::GetCallStackCurStr( int depth ) { return ""; }
void                    idSysLocal::ShutdownSymbols( void ) {}

int                             idSysLocal::DLL_Load( const char *dllName ) { return 0; }
void *                  idSysLocal::DLL_GetProcAddress( int dllHandle, const char *procName ) { return NULL; }
void                    idSysLocal::DLL_Unload( int dllHandle ) { }
void                    idSysLocal::DLL_GetFileName( const char *baseName, char *dllName, int maxLength ) { }

sysEvent_t              idSysLocal::GenerateMouseButtonEvent( int button, bool down ) { sysEvent_t ev; memset( &ev, 0, sizeof( ev ) ); return ev; }
sysEvent_t              idSysLocal::GenerateMouseMoveEvent( int deltax, int deltay ) { sysEvent_t ev; memset( &ev, 0, sizeof( ev ) ); return ev; }

void                    idSysLocal::OpenURL( const char *url, bool quit ) { }
void                    idSysLocal::StartProcess( const char *exeName, bool quit ) { }

void                    idSysLocal::FPU_EnableExceptions( int exceptions ) { }

idSysLocal              sysLocal;
idSys *                 sys = &sysLocal;


/*
==============================================================

        main

==============================================================
*/

int main( int argc, char** argv ) {
        idStr fileName, sourcePath;
        idTypeInfoGen *generator;

        idLib::common = common;
        idLib::cvarSystem = cvarSystem;
        idLib::fileSystem = fileSystem;
        idLib::sys = sys;

        idLib::Init();
        cmdSystem->Init();
        cvarSystem->Init();
        idCVar::RegisterStaticVars();
        fileSystem->Init();

        generator = new idTypeInfoGen;

        if ( argc > 1 ) {
                sourcePath = idStr( "../"SOURCE_CODE_BASE_FOLDER"/" ) + argv[1];
        } else {
                sourcePath = "../"SOURCE_CODE_BASE_FOLDER"/game";
        }

        if ( argc > 2 ) {
                fileName = idStr( "../"SOURCE_CODE_BASE_FOLDER"/" ) + argv[2];
        } else {
                fileName = "../"SOURCE_CODE_BASE_FOLDER"/game/gamesys/GameTypeInfo.h";
        }

        if ( argc > 3 ) {
                for ( int i = 3; i < argc; i++ ) {
                        generator->AddDefine( argv[i] );
                }
        } else {
                generator->AddDefine( "__cplusplus" );
                generator->AddDefine( "GAME_DLL" );
                generator->AddDefine( "ID_TYPEINFO" );
        }

        generator->CreateTypeInfo( sourcePath );
        generator->WriteTypeInfo( fileName );

        delete generator;

        fileName.Clear();
        sourcePath.Clear();

        fileSystem->Shutdown( false );
        cvarSystem->Shutdown();
        cmdSystem->Shutdown();
        idLib::ShutDown();

        return 0;
}