xmog_jvm_options.h

//
// Copyright (c) 1999-2020 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 
};
 
 
#if (XMOG_SUPPORTS_JNI_11==1)
 
    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();
 
    virtual void                addAgentLib( const char * pAgentLib );
 
    virtual void                addAgentPath( const char * pAgentPath );
 
    virtual void                addJavaAgent( const char * pJavaAgent );
 
#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
    
    virtual void                addModules( const char * pMdules );
 
    virtual void                setModulePath( const char * mp );
 
    virtual void                appendToModulePath( const char * mp );
 
    virtual void                prependToModulePath( const char * mp );
 
    virtual char *              getModulePath();
    
    virtual void                addOpens( const char * pMod, const char * pPackage, const char * pReadingModule = "ALL-UNNAMED" );
    
    virtual void                addExports( const char * pMod, const char * pPackage, const char * pReadingModule = "ALL-UNNAMED" );
    
    virtual void                addReads( const char * pModule, const char * pModules );
 
    
    
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 );
 
#   if (XMOG_SUPPORTS_JNI_11==1)
 
    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 */