xmog_jvm_options.h

/*
 * Copyright 1999-2006 by Codemesh, Inc.  ALL RIGHTS RESERVED.
 */

#ifndef xmog_jvm_options_inc
#define xmog_jvm_options_inc


#include "xmog.h"

extern "C" {
typedef void (JNICALL *XMOG_ABORT)();
typedef void (JNICALL *XMOG_EXIT)(jint);
typedef jint (JNICALL *XMOG_VFPRINTF)(FILE*,const char*,va_list);
};

enum xmog_jvm_verbosity
{
    VerbosityUndefined = -1, 
    VerbosityNone = 0, 
    VerbosityClass=1, 
    VerbosityGC=2, 
    VerbosityJNI=4, 
    VerbosityAll=7 
};


#ifdef XMOG_SUPPORTS_JNI_11

    enum xmog_bytecode_verification
    {
        VerifyUndefined = -1,
        VerifyNone = 0,
        VerifyRemote = 1,
        VerifyAll = 2
    };

#endif //XMOG_SUPPORTS_JNI_11

class XMOG_DECLSPEC xmog_jvm_options
{
protected:

    xmog_jvm_options( bool bEnvOverrides = true );

    xmog_jvm_options( const char * filename, bool bEnvOverrides = true );

public:

    xmog_jvm_options( const char * filename, XMOGVERSION vers, XMOGCONFIG conf, XMOGVERSION reserved0, bool bEnvOverrides = true );

protected:

    xmog_jvm_options( XMOGVERSION vers, XMOGCONFIG conf, XMOGVERSION reserved0, bool bEnvOverrides = true );

    xmog_jvm_options( int argc, char * argv[], bool bEnvOverrides = true );

public:

    virtual ~xmog_jvm_options();

    virtual void *              getInitArgs( jint jniVersion );

    virtual int                 readJvmOptions( const char * file, XMOGVERSION vers = NULL, XMOGCONFIG conf = NULL, XMOGVERSION reserved0 = NULL );

    virtual void                reset();

    virtual void                setJniVersion( jint version );

    virtual void                setJniVersion( const char * version );

    virtual jint                getJniVersion();

    virtual void                setIgnoreUnrecognized( bool ignore );

    virtual void                setIgnoreUnrecognized( const char * ignore );

    virtual bool                getIgnoreUnrecognized();

    virtual void                setStackSizeInKB( jint ss );

    virtual void                setStackSize( const char * ss );

    virtual jint                getStackSizeInKB();

    virtual void                setInitialHeapSizeInMB( jint ihs );

    virtual void                setInitialHeapSize( const char * ihs );

    virtual jint                getInitialHeapSizeInMB();

    virtual void                setMaximumHeapSizeInMB( jint mhs );

    virtual void                setMaximumHeapSize( const char * mhs );

    virtual jint                getMaximumHeapSizeInMB();

    virtual void                setDashDOption( const char * name, const char * value = 0 );

    virtual char *              getDashDOption( const char * name );

    virtual void                removeDashDOption( const char * name );

    virtual void                setDashXOption( const char * name, const char * value = 0 );

    virtual char *              getDashXOption( const char * name );

    virtual void                removeDashXOption( const char * name );

    virtual void                setOtherOption( const char * namevalue, void * ptr = 0 );

    virtual void *              getOtherOption( const char * name );

    virtual void                removeOtherOption( const char * name );

    virtual void                setClassPath( const char * cp );

    virtual void                appendToClassPath( const char * cp );

    virtual void                prependToClassPath( const char * cp );

    virtual char *              getClassPath();

    virtual void                setLibraryPath( const char * lp );

    virtual void                appendToLibraryPath( const char * lp );

    virtual char *              getLibraryPath();

    virtual void                setExtensionsDirectories( const char * ed );

    virtual void                appendToExtensionsDirectories( const char * ed );

    virtual char *              getExtensionsDirectories();

    virtual void                setSecurityManager( const char * sm );

    virtual char *              getSecurityManager();

    virtual void                setSecurityPolicy( const char * policyFile );

    virtual char *              getSecurityPolicy();

    virtual void                setVfprintf( XMOG_VFPRINTF vfp );

    virtual void                setVfprintf( const char * vfp );

    virtual XMOG_VFPRINTF       getVfprintf();

    virtual void                setExit( XMOG_EXIT ex );

    virtual void                setExit( const char * ex );

    virtual XMOG_EXIT           getExit();

    virtual void                setAbort( XMOG_ABORT ab );

    virtual void                setAbort( const char * ab );

    virtual XMOG_ABORT          getAbort();

    virtual void                setDisableClassGC( bool dcgc );

    virtual void                setDisableClassGC( const char * dcgc );

    virtual bool                getDisableClassGC();

    virtual void                setEnableClassGC( bool ecgc );

    virtual void                setEnableClassGC( const char * ecgc );

    virtual bool                getEnableClassGC();

    virtual void                setEnableVerboseGC( bool evgc );

    virtual void                setEnableVerboseGC( const char * evgc );

    virtual bool                getEnableVerboseGC();

    virtual void                setEnabledAssertions( const char * ea );

    virtual void                appendToEnabledAssertions( const char * ea );

    virtual char *              getEnabledAssertions();

    virtual void                setDisabledAssertions( const char * da );

    virtual void                appendToDisabledAssertions( const char * da );

    virtual char *              getDisabledAssertions();

    virtual void                setEnableSystemAssertions( bool esa );

    virtual void                setEnableSystemAssertions( const char * esa );

    virtual bool                getEnableSystemAssertions();

    virtual void                setDisableSystemAssertions( bool dsa );

    virtual void                setDisableSystemAssertions( const char * dsa );

    virtual bool                getDisableSystemAssertions();

    virtual void                setVerbosity( int v );

    virtual void                setVerbosity( const char * v );

    virtual void                setVerbosity( xmog_jvm_verbosity v );

    virtual xmog_jvm_verbosity  getVerbosity();

    virtual void                setMixedMode( bool m );

    virtual void                setMixedMode( const char * m );

    virtual bool                getMixedMode();

    virtual void                setInterpretedMode( bool i );

    virtual void                setInterpretedMode( const char * i );

    virtual bool                getInterpretedMode();

    virtual void                setAppendBootClassPath( const char * cp );

    virtual void                appendToAppendBootClassPath( const char * cp );

    virtual char *              getAppendBootClassPath();

    virtual void                setPrependBootClassPath( const char * cp );

    virtual void                appendToPrependBootClassPath( const char * cp );

    virtual char *              getPrependBootClassPath();

    virtual void                setBootClassPath( const char * cp );

    virtual void                appendToBootClassPath( const char * cp );

    virtual char *              getBootClassPath();

    virtual void                setIncrementalGC( bool i );

    virtual void                setIncrementalGC( const char * i );

    virtual bool                getIncrementalGC();

    virtual void                setLogGCFile( const char * file );

    virtual char *              getLogGCFile();

    virtual void                setBatchMode( bool b );

    virtual void                setBatchMode( const char * b );

    virtual bool                getBatchMode();

    virtual void                setProf( bool p );

    virtual void                setProf( const char * p );

    virtual bool                getProf();

    virtual void                setRun( const char * runopts );

    virtual char *              getRun();

    virtual void                setDebug( bool d );

    virtual void                setDebug( const char * d );

    virtual bool                getDebug();

    virtual void                setNoagent( bool na );

    virtual void                setNoagent( const char * na );

    virtual bool                getNoagent();

    virtual void                setReduceSignals( bool rs );

    virtual void                setReduceSignals( const char * rs );

    virtual bool                getReduceSignals();

    virtual void                setCheckJni( bool cjni );

    virtual void                setCheckJni( const char * cjni );

    virtual bool                getCheckJni();

    virtual void                setFuture( bool future );

    virtual void                setFuture( const char * future );

    virtual bool                getFuture();

#if (XMOG_SUPPORTS_JNI_11==1)

    virtual void                mergeWithDefaults( JDK1_1InitArgs & iargs11 );

    virtual void                setCheckSource( bool cs );

    virtual bool                getCheckSource();

    virtual void                setNativeStackSizeInKB( jint nss );

    virtual jint                getNativeStackSizeInKB();

    virtual void                setVerifyMode( xmog_bytecode_verification ver );

    virtual xmog_bytecode_verification getVerifyMode();

    virtual void                setDisableAsyncGC( bool dagc );

    virtual bool                getDisableAsyncGC();

#endif //XMOG_SUPPORTS_JNI_11

protected:
        
    void                env_override();

private:

    // the JVM options

    JavaVMInitArgs      iargs_12;

    int                 iargs_12_alloc;

    void                init();

    bool                envOverrides;

    int                 readJvmOptionsFromRegistry( XMOGVERSION vers, XMOGCONFIG conf, XMOGVERSION reserved0 );

    int                 readJvmOptionsInJunction20Format( const char * file, XMOGVERSION vers, XMOGCONFIG conf, XMOGVERSION reserved0 );

    int                 readJvmOptionsInXmlFormat( const char * file );

    JavaVMOption *      find12Option( const char * prefix, const char * name, size_t combined_length = 0 );

    void                add12Option( const char * prefix, const char * name, char sep, const char * value = 0, void * extra = 0 );

    void                remove12Option( const char * prefix, const char * name );

    void                append12Option( const char * prefix, const char * name, char sep, const char * value );

    void                setVerbosity_( const char * verbosity );

#   ifdef XMOG_SUPPORTS_JNI_11

    int                 iargs_11_alloc;

    int                 iargs_11_used;

    JDK1_1InitArgs      iargs_11;

    unsigned            iargs_11_modified;

    void                appendString( char ** ptr, char sep, const char * str );

    char **             find11Option( const char * name, size_t length = 0 );

    void                add11Option( const char * name, const char * value = 0 );

    void                remove11Option( const char * name );

#   endif //XMOG_SUPPORTS_JNI_11

};



#endif /* xmog_jvm_options_inc */

---