eclipse 参数 收藏

-Xms160m
-Xmx160m
-XX:PermSize=96M
-XX:MaxPermSize=96M

In JDK 1.2, the default setting for verification is the same, only verify classes loaded over the network. However, the system classes are specified from something other than the CLASSPATH environment variable, and the command line options for verification differ. The system classes are specified by either the System property sun.boot.class.path or the command line option -Xbootclasspath:directories and jar files. This is automatically set for you by the JRE and should never need to be set manually. If you set it to add something yourself be sure to include the original defaults, too. With regards to verification, if you wish to manually control the level of verification, the options to the java command with the V1.2 JRE are as follows:

• -Xverify:remote - only perform verification process on classes loaded over network (default)
• -Xverify:all - verify everything
• -Xverify:none - verify nothing

Platform Plug-in Developer Guide > Reference > Other reference information

The Eclipse runtime options

Version 3.3 - Last revised May 31, 2007

The Eclipse platform is highly configurable. Configuration input takes the form of command line arguments and System property settings. In many cases the command line arguments are simply short cuts for setting the related System properties. In fact, there are many more System property settings than command line arguments.

Command line arguments

Listed below are the command line arguments processed by various parts of the Eclipse runtime. Many of these values can also be specified using System properties either on the command line using -D VM arguments, by specifying their values in a config.ini file or by using a <launcher>.ini file. Using the two latter techniques it is possible to customize your Eclipse without using command line arguments at all.

For each argument in the list, its corresponding System property key is given (in {}). Also given is the Eclipse runtime layer in which the command line argument is processed (in ()). This is useful for people replacing parts of the runtime to suit special needs.

-application <id> (Runtime)

equivalent to setting eclipse.application to <id>

-arch <architecture> (OSGi)

equivalent to setting osgi.arch to <architecture>

-clean (OSGi)

equivalent to setting osgi.clean to "true"

-configuration <location> (Main)

equivalent to setting osgi.configuration.area to <location>

-console [port] (OSGi)

equivalent to setting osgi.console to [port] or the empty string if the default port is to be used (i.e., when the port is not specified)

-consoleLog (Runtime)

equivalent to setting eclipse.consoleLog to "true"

-data <location> (OSGi)

equivalent to setting osgi.instance.area to <location>

-debug [options file] (OSGi)

equivalent to setting osgi.debug to [options file] or the empty string to simply enable debug (i.e., if the options file location is not specified)

-dev [entries] (OSGi)

equivalent to setting osgi.dev to [entries] or the empty string to simply enable dev mode (i.e., if entries are not specified)

-feature <feature id> (Runtime)

equivalent to setting eclipse.product to <feature id>

-framework <location> (Main)

equivalent to setting osgi.framework to <location>

-initialize (Main)

initializes the configuration being run. All runtime related data structures and caches are refreshed. Any user/plug-in defined configuration data is not purged. No application is run, any product specifications are ignored and no UI is presented (e.g., the splash screen is not drawn)

-install <location> (Main)

equivalent to setting osgi.install.area to <location>

-keyring <location> (Runtime)

the location of the authorization database on disk. This argument has to be used together with the -password argument.

--launcher.library <location> (Executable) NEW

the location of the eclipse executable's companion shared library.  If not specified the executable looks in the plugins directory for the appropriate org.eclipse.equinox.launcher.[platform] fragment with the highest version and uses the shared library named eclipse_* inside.

--launcher.ini <location> (Executable) NEW

the location of the product .ini file to use.  If not specified the executable will look for a file beside the launcher with the same name and the extension .ini.  (ie eclipse.exe looks for eclipse.ini, product.exe looks for product.ini)

--launcher.suppressErrors (Executable) NEW

If specified the executable will not display any error or message dialogs.  This is useful if the executable is being used in an unattended situation.

--launcher.secondThread (Executable)  NEW MACOSX ONLY

If specified the executable will create the Java VM on a secondary thread.  This should used if a swing application is being run. SWT will NOT work if this option is specified.

--launcher.XXMaxPermSize <value> (Executable) NEW

If specified, and the executable detects that the VM being used is a Sun VM, then the launcher will automatically add the -XX:MaxPermSize=<value> vm argument.  The executable is not capable of detecting Sun VMs on all platforms.

-name <string> NEW

The name to be displayed in task bar item when the application starts up. When not set, the name is the name of the executable.

-nl <locale> (OSGi)

equivalent to setting osgi.nl to <locale>

-noExit (OSGi)

equivalent to setting osgi.noShutdown to "true"

-noLazyRegistryCacheLoading (Runtime)

equivalent to setting eclipse.noLazyRegistryCacheLoading to "true"

-noRegistryCache (Runtime)

equivalent to setting eclipse.noRegistryCache to "true"

-noSplash (Executable, Main)

controls whether or not the splash screen is shown

-os <operating system> (OSGi)

equivalent to setting osgi.os to <operating system>

-password <password> (Runtime)

the password for the authorization database

-pluginCustomization <location> (Runtime)

equivalent to setting eclipse.pluginCustomization to <location>

-product <id> (OSGi)

equivalent to setting eclipse.product to <id>

-showSplash <bitmap> (Executable, Main) NEW

specifies the bitmap to use in the splash screen. If specified, the launcher may be able to show the splash screen before starting the Java VM.  If not specified, Main will find the bitmap using the osgi.splashLocation and osgi.splashPath properties.

-startup <location> (Executable) NEW

The location of jar used to startup eclipse. The jar referred to should have the Main-Class attribute set to org.eclipse.equinox.launcher.Main. If this parameter is not set, the executable will look in the plugins directory for theorg.eclipse.equinox.launcher bundle with the highest version.

-user <location> (OSGi)

equivalent to setting osgi.user.area to <location>

-vm <path to java vm> (Executable, Main)

when passed to the Eclipse executable, this option is used to locate the Java VM to use to run Eclipse. It should be the full file system path to an appropriate: Java jre/bin directory, Java Executable, Java shared library (jvm.dll or libjvm.so), or a Java VM Execution Environment description file.  If not specified, the Eclipse executable uses a search algorithm to locate a suitable VM. In any event, the executable then passes the path to the actual VM used to Java Main using the -vm argument. Java Main then stores this value in eclipse.vm.

-vmargs [vmargs*] (Executable, Main)

when passed to the Eclipse, this option is used to customize the operation of the Java VM to use to run Eclipse. If specified, this option must come at the end of the command line. Even if not specified on the executable command line, the executable will automatically add the relevant arguments (including the class being launched) to the command line passed into Java using the -vmargs argument. Java Main then stores this value in eclipse.vmargs.

-ws <window system> (OSGi)

equivalent to setting osgi.ws to <window system>

Obsolete command line arguments

The following command line arguments are no longer relevant or have been superceded and are consumed by the runtime and not passed on to the application being run to maintain backward compatibility. .

-boot

see -configuration

-classLoaderProperties

no longer relevant

-endSplash <command>

no longer relevant

-firstUse

no longer relevant

-newUpdates

no longer relevant

-noPackagePrefixes

no longer relevant

-noUpdate

no longer relevant

-plugins

no longer relevant

-update

no longer relevant

Others

The following command line arguments are defined by various Eclipse plug-ins and are only supported if the defining plug-in is installed, resolved and activated.

-noVersionCheck (workbench)

<description>

-perspective (workbench)

<description>

-refresh (org.eclipse.core.resources)

<description>

-showLocation (org.eclipse.ui.ide.workbench)

<description>

-allowDeadlock

<description>

System properties

The following System properties are used by the Eclipse runtime. Note that those starting with "osgi" are specific to the OSGi framework implementation while those starting with "eclipse" are particular to the Eclipse runtime layered on top of the OSGi framework.

Many of these properties have command line equivalents (see the command line arguments section and the value in braces {}). Users are free to use either command line or property settings to specify a value. Properties can be set in the following ways:

• use -DpropName=propValue as a VM argument to the Java VM
• set the desired property in the config.ini file in the appropriate configuration area

eclipse.activateRuntimePlugins

controls activation of runtime plug-ins. RCP applications not requiring services provided by runtime plug-ins can set this property to "false" to avoid activation of runtime plug-ins on Eclipse startup

eclipse.allowAppRelaunch

if set to "true" then the main thread will continue to wait for another application descriptor to be launched after the currently running application has quit. Stopping the system.bundle (i.e. the bundle with a bundle ID equel to zero) will force the main thread to stop waiting for another application to launch. The default value is "false"

eclipse.application {-application}

the identifier of the application to run. The value given here overrides any application defined by the product (see eclipse.product) being run

eclipse.application.launchDefault

Controls launching the default application automatically once the platform is running. A default application is identified by the eclipse.product or the eclipse.application options. The default value is "true". Setting this property to "false" will prevent the default application from launching automatically. Once the platform is running the main thread will wait for an application to be launched using an application descriptor service.

eclipse.application.registerDescriptors

Controls registration of application descriptor services for all installed applications. The default value is "false". If set to "false" only the default application will have an application descriptor service registered. If set to "true" then all installed applications will have an application descriptor service registered.

eclipse.commands

a new-line separated list of all command-line arguments passed in when launching Eclipse

eclipse.consoleLog

if "true", any log output is also sent to Java's System.out (typically back to the command shell if any). Handy when combined with -debug

eclipse.debug.startupTime

the time in milliseconds when the Java VM for this session was started

eclipse.ee.install.verify

if set to "true" then the framework will check the required execution environment at bundle install time. The default value is "false".

eclipse.exitOnError

if set to "true" then the platform will exit if an unhandled error occurs. The default value is "true".

eclipse.ignoreApp

if set to "true" then the main launching thread will not start the default application and will proceed in shutting down the platform and exiting. The default value is "false". This is different than the eclipse.application.launchDefault option because the main thread will not wait for an application descriptor service to be launched.

eclipse.log.backup.max

the max number of backup log files to allow. The oldest backup log file will be deleted after the max number of backup log files is reached as a result of rotating the log file. The default value is "10". A negative or zero value will cause the default value to be used.

eclipse.log.size.max

the max size in Kb that the log file is allowed to grow. The log file is rotated when the file size exceeds the max size. The default value is "1000". A negative value will cause the default value to be used. A zero value indicates no max log size.

eclipse.noExtensionMunging

if "true", legacy registry extension are left as-is. By default such extensions are updated to use the new extension point ids found in Eclipse 3.0.

eclipse.noLazyRegistryCacheLoading {-noLazyRegistryCacheLoading}

if "true", the platform's plug-in registry cache loading optimization is deactivated. By default, configuration elements are loaded from the registry cache (when available) only on demand, reducing memory footprint. This option forces the registry cache to be fully loaded at startup.

eclipse.noRegistryCache {-noRegistryCache}

if "true", the internal extension registry cache is neither read or written

eclipse.pluginCustomization {-pluginCustomization}

the file system location of a properties file containing default settings for plug-in preferences. These default settings override default settings specified in the primary feature. Relative paths are interpreted relative to the current working directory for eclipse itself.

eclipse.product {-product}

the identifier of the product being run. This controls various branding information and what application is used.

eclipse.service.jobs

controls registration of OSGi services. Set to "false" to suppress registration of OSGi services by the org.eclipse.core.jobs plug-in

eclipse.service.pref

Controls registration of OSGi services. Set to "false" to suppress registration of OSGi services by the org.eclipse.equinox.preferences plug-in

eclipse.startTime

This property is set at the time eclipse is started. The value of this property a string representation of the value returned by System.currentTimeMillis(). This value is not intended to be set by users.

eclipse.stateSaveDelayInterval

the delay interval (in milliseconds) for persisting state change requests. The default is 30000 ms (30 seconds). State change requests are delayed to prevent massive amounts of disk writes while performing administrative operations (e.g. installing bundles). The delay interval is used to wait for a period of inactivity before persisting the framework state information.

eclipse.vm {-vm}

the path to the Java executable used to run Eclipse. This information is used to construct relaunch command lines.

eclipse.vmargs {-vmargs}

lists the VM arguments used to run Eclipse. This information is used to construct relaunch command lines.

osgi.adaptor

the class name of the OSGi framework adaptor to use.

osgi.arch {-arch}

see -arch

osgi.baseConfiguration.area

specifies a base configuration that is used when osgi.configuration.area is not specified.

osgi.bundlefile.limit

specifies a limit on the number of jar files the framework will keep open. The minimum value allowed is 10. By default the value is unlimited.

osgi.bundles

The comma-separated list of bundles which are automatically installed and optionally started once the system is up and running. Each entry is of the form:

    <URL | simple bundle location>[@ [<start-level>] [":start"]]

If the start-level (>0 integer) is omitted then the framework will use the default start level for the bundle. If the "start" tag is added then the bundle will be marked as started after being installed. Simple bundle locations are interepreted as relative to the framework's parent directory. The start-level indicates the OSGi start level at which the bundle should run. If this value is not set, the system computes an appropriate default.

osgi.bundles.defaultStartLevel

this is the startlevel that all bundles will be set to if installed by Eclipse Update. Bundles which are specified on the osgi.bundles list can specify a particular startlevel. If they do not specify a startlevel then they default to the value of osgi.bundles.defaultStartLevel. The default value of osgi.bundles.defaultStartLevel is 4.

osgi.compatibility.bootdelegation

if set to "true" then the parent (boot by default) classloader is delegated to as a last resort if a class or resource cannot be found. The default value is "true".

osgi.compatibility.errorOnFailedStart

A bundle may specify a lazy activation policy using the bundle manifest headers Eclipse-LazyStart or Bundle-ActivationPolicy. According to the OSGi R4.1 specification, if a bundle with a lazy activation policy fails to start then class loads must still succeed. Before the OSGi R4.1 specification Eclipse defined the lazy activation policy such that failed starts would cause class loading errors to be thrown. If osgi.compatibility.errorOnFailedStart is set to "true" then failed starts will result in class loading errors; otherwise the activation error is logged and the classes are allowed to load from bundles which failed to start. The default value is "true".

osgi.compatibility.eagerStart.LazyActivation

The OSGi R4.1 specification mandates that all bundles must be marked for start before they are allowed to activate. This includes bundles which specify a lazy activation policy. A new method Bundle.start(options) has been added to allow lazy activated bundles to be activated according to their lazy activation policy. Before the OSGi R4.1 specification Eclipse defined the lazy activation policy such that lazy activated were automatically activated on first class load even though they were not marked for activation. If osgi.compatibility.eagerStart.LazyActivation is set to "true" then bundles with the lazy activation policy will automatically be marked for activation; otherwise bundles with the lazy activation policy must be started with the new Bundle.start(options) method before being allowed to lazy activate. The default value is "true".

osgi.checkConfiguration

if set to "true" then timestamps are check in the configuration cache to ensure that the cache is up to date with respect to the contents of the installed bundles. The default value is "false".

osgi.classloader.singleThreadLoads

if set to "true" then only one thread is allowed to load a class at a time. The default value is "false". This option can be used to work around certain VM bugs which can cause deadlock. See bug 121737

osgi.clean

if set to "true", any cached data used by the OSGi framework and eclipse runtime will be wiped clean. This will clean the caches used to store bundle dependency resolution and eclipse extension registry data. Using this option will force eclipse to reinitialize these caches.

osgi.configuration.cascaded

if set to "true", this configuration is cascaded to a parent configuration. The parent configuration is specified by the osgi.sharedConfiguration.area. See the section on locations for more details.

osgi.configuration.area {-configuration}

the configuration location for this run of the platform. The configuration determines what plug-ins will run as well as various other system settings. See the section on locations for more details.

osgi.configuration.area.default

the default configuration location for this run of the platform. The configuration determines what plug-ins will run as well as various other system settings. This value (i.e., the default setting) is only used if no value for the osgi.configuration.area is set. See the section on locations for more details.

osgi.console {-console}

if set to a non-null value, the OSGi console (if installed) is enabled. If the value is a suitable integer, it is interpreted as the port on which the console listens and directs its output to the given port. Handy for investigating the state of the system.

osgi.console.class

the class name of the console to run if requested

osgi.console.encoding

if set then the specified value is used as the encoding for the console (see osgi.console). If not set then the value of the file.encoding property is used. If file.encoding is not set then iso8859-1 is used as the default.

osgi.contextClassLoaderParent

the classloader type to use as the parent classloader of the context classloader used by the Framework. The valid types are the following:

• app - the application classloader.
• boot - the boot classloader.
• ext - the extension classloader.
• fwk - the framework classloader.
• ccl - the original context classloader that was set when the framework launched (default value).

osgi.debug {-debug}

if set to a non-null value, the platform is put in debug mode. If the value is a string it is interpreted as the location of the .options file. This file indicates what debug points are available for a plug-in and whether or not they are enabled. If a location is not specified, the platform searches for the .options file under the install directory.

osgi.dev {-dev}

if set to the empty string, dev mode is simply turned on. This property may also be set to a comma-separated class path entries which are added to the class path of each plug-in or a URL to a Java properties file containing custom classpath additions for a set of plug-ins. For each plug-in requiring a customized dev time classpath the file will contain an entry of the form

    <plug-in id>=<comma separated list of classpath entries to add>

where plug-in id "*" matches any plug-in not otherwise mentioned.

osgi.filepermissions.command

specifies an optional OS specific command to set file permissions on extracted native code. On some operating systems it is required that native libraries be set to executable. This optional property allows you to specify the command. For example, on a UNIX style OS you could have the following value:

    osgi.filepermissions.command="chmod +rx [fullpath]"

The [fullpath] is used to substitute the actual file path by the framework.

osgi.framework

the URL location of the OSGi framework. Useful if the Eclipse install is disjoint. See the section on locations for more details.

osgi.frameworkClassPath

a comma separated list of classpath entries for the OSGi framework implementation. Relative locations are interpreted as relateve to the framework location (see osgi.framework)

osgi.framework.extensions

a comma-separated list of framework extensions. Each entry is of the form:

    <simple bundle location>

Simple bundle locations are searched in the parent directory of the org.eclipse.osgi bundle. Framework extensions may be used to run Eclipse with a different framework adaptor. The framework extension may contain an eclipse.properties file to set system properties. For example, a framework extension that provides a framework adaptor implementation can specify what the adaptor class is by setting the osgi.adaptor property.

osgi.framework.shape

set to the shape of the Eclipse OSGi Framework implementation. This property is set when the Eclipse platform is started and is not intended by be set by the user. The value "jar" indicates that the Eclipse OSGi Framework is contained in a single jar. The value "folder" indicates that the Eclipse OSGi Framework is contained in a directory.

osgi.framework.library.extensions

a comma separated list of additional library file extensions that must be searched for. If not set then only the library name returned by System.mapLibraryName(String) will be used to search. This is needed for certain operating systems which allow more than one extension for a library. For example AIX allows library extensions of .a and .so, but System.mapLibraryName(String) will only return names with the .a extension.

osgiframeworkParentClassloader

the classloader type to use as the parent classloader for the the Framework. The valid types are the following:

• app - the application classloader.
• boot - the boot classloader.
• ext - the extension classloader.
• current - the classloader used to load the equinox launcher.

osgi.framework.useSystemProperties

controls whether the framework properties are backed by the global System properties or held privately for each instance of the framework. By default the framework properties are backed by the System properties (e.g. true). This property is useful when running multiple instances of the OSGi Framework within the same VM and each instance has a separate set of configuration properties (e.g. set in the config.ini).

osgi.genericAliases

a comma separated list of generic aliases that can be used to map existing manifest headers onto Eclipse-GenericCapability and Eclipse-GenericRequire manifest headers. The osgi.genericAliases property uses the following syntax:

  osgi.genericAliases ::= generic-alias ( ',' generic-alias ) *
  generic-alias       ::= capability-alias ':' require-alias ':' capability-type

For example, to map the OSGi headers Export-Service and Import-Service headers onto Eclipse-GenericCapability and Eclipse-GenericRequire headers you would use the following value:

  osgi.genericAliases=Export-Service:Import-Service:osgi.service

osgi.hook.configurators

a comma separated list of hook configurators. If this property is set then the list of configurators specified will be the only configurators used. Any hook configurators specified in hookconfigurators.properties files will be ignored.

osgi.hook.configurators.include

a comma separated list of additional hook configuratiors. This is helpful for configuring optional hook configurators. This option is ignored if the osgi.hook.configurators option is used.

osgi.hook.configurators.exclude

a comma separated list of hook configurators to exclude. This is helpful for disabling hook configurators that are specified in hook configurator properties files. This option is ignored if the osgi.hook.configurators option is used.

osgi.java.profile

a URL to the JRE profile file to use. The specified URL is read as a Java properties file. A JRE profile contains values for the properties org.osgi.framework.system.packages, org.osgi.framework.bootdelegation and org.osgi.framework.executionenvironment. If the osgi.java.profile is not set then a profile is selected based on the java.specification.version value of the running JRE.

osgi.java.profile.bootdelegation

a java profile osgi.java.profile may contain a "org.osgi.framework.bootdelegation" property. This value may be used to set the system property "org.osgi.framework.bootdelegation". The osgi.java.profile.bootdelegation indicates the policy for bootdelegation to be used. The following values are valid (default is ignore):

• ignore - indicates that the "org.osgi.framework.bootdelegation" value in the java profile should be ingored. The system property "org.osgi.framework.bootdelegation" will be used to determine which packages should be delegated to boot.
• override - indicates that the "org.osgi.framework.bootdelegation" in the java profile should override the system property "org.osgi.framework.bootdelegation".
• none - indicates that the "org.osgi.framework.bootdelegation" in the java profile AND the system properties should be ignored. This is the most strict option. Running with this option causes the framework to use the OSGi R4 strict boot delegation model.

osgi.install.area {-install}

the install location of the platform. This setting indicates the location of the basic Eclipse plug-ins and is useful if the Eclipse install is disjoint. See the section on locations for more details.

osgi.instance.area {-data}

the instance data location for this session. Plug-ins use this location to store their data. For example, the Resources plug-in uses this as the default location for projects (aka the workspace). See the section on locations for more details.

osgi.instance.area.default

the default instance data location for this session. Plug-ins use this location to store their data. For example, the Resources plug-in uses this as the default location for projects (aka the workspace). This value (i.e., the default setting) is only used if no value for the osgi.instance.area is set. See the section on locations for more details.

osgi.locking

the locking type to use for this run of the platform. The valid locking types are "java.io", "java.nio", and "none". The default value is "java.nio" unless the JRE does not support "java.nio" then "java.io" is the default.

osgi.manifest.cache

the location where generated manifests are discovered and generated. The default is in the configuration area but the manifest cache can be stored separately.

osgi.nl {-nl}

the name of the locale on which Eclipse platform will run. NL values should follow the standard Java locale naming conventions.

osgi.nl.user

the name of the locale when the user explicitly adds -nl to the command-line arguments.

osgi.noShutdown {-noExit}

if "true", the VM will not exit after the eclipse application has ended. This is useful for examining the OSGi framework after the eclipse application has ended.

osgi.os {-os}

the operating system value. The value should be one of the Eclipse processor architecture names known to Eclipse (e.g., x86, sparc, ...).

osgi.parentClassloader

the classloader type to use as the parent classloader for all bundles installed in the Framework. The valid types are the following:

• app - the application classloader.
• boot - the boot classloader.
• ext - the extension classloader.
• fwk - the framework classloader.

osgi.requiredJavaVersion

The minimum java version that is required to launch Eclipse. The default value is "1.4.1".

osgi.resolverMode

the mode used to resolve bundles installed in the Framework. A value of "strict" puts the resolver in strict mode. The default resolver mode is not strict. When the resolver is in strict mode the Framework will enforce access restriction rules when loading classes and resources from exported packages which specify the x-internal or x-friends directives.

osgi.sharedConfiguration.area

the shared configuration location for this run of the platform. If the osgi.configuration.cascaded property is set to "true" then shared configuration area is used as the parent configuration.

osgi.splashLocation

the absolute URL location of the splash screen (.bmp file) to to show while starting Eclipse. This property overrides any value set in osgi.splashPath.

osgi.splashPath

a comma separated list of URLs to search for a file called splash.bmp. This property is overriden by any value set in osgi.splashLocation.

osgi.startLevel

the start level value the framework will be set to at startup. The default value is 6.

osgi.support.signature.verify

A comma separated list of options for signed bundle signature verification. The valid types are the following:

• certificate - enables parsing and verification of certificates.
• trust - enables verification of certificate trust. This option implies "certificate".
• runtime - enables verification of signed bundle content at runtime. This option implies "certificate".
• all - same as "certificate,trust,runtime".
• true - same as "all". that was set when the framework launched (default value).

osgi.syspath

set to the path where the eclipse OSGi Framework (org.eclipse.osgi) implementation is located. For example, "<eclipse install path>/eclipse/plugins". This property is set when the Eclipse platform is started and is not intended by be set by the user.

osgi.user.area {-user}

the location of the user area. The user area contains data (e.g., preferences) specific to the OS user and independent of any Eclipse install, configuration or instance. See the section on locations for more details.

osgi.user.area.default

the default location of the user area. The user area contains data (e.g., preferences) specific to the OS user and independent of any Eclipse install, configuration or instance. This value (i.e., the default setting) is only used if no value for the osgi.user.area is set. See the section on locations for more details.

osgi.ws {-ws}

the window system value. The value should be one of the Eclipse window system names known to Eclipse (e.g., win32, motif, ...).

Locations

The Eclipse runtime defines a number of locations which give plug-in developers context for reading/storing data and Eclipse users a control over the scope of data sharing and visibility. Eclipse defines the following notions of location:

User (-user) {osgi.user.area} [@none, @noDefault, @user.home, @user.dir, filepath, url]

User locations are specific to, go figure, users. Typically the user location is based on the value of the Java user.home system property but this can be overridden. Information such as user scoped preferences and login information may be found in the user location.

Install (-install) {osgi.install.area} [@user.home, @user.dir, filepath, url]

An install location is where Eclipse itself is installed. In practice this location is the directory (typically "eclipse") which is the parent of the eclipse.exe being run or the plugins directory containing the org.eclipse.equinox.launcher bundle. This location should be considered read-only to normal users as an install may be shared by many users. It is possible to set the install location and decouple eclipse.exe from the rest of Eclipse.

Configuration (-configuration) {osgi.configuration.area} [@none, @noDefault, @user.home, @user.dir, filepath, url]

Configuration locations contain files which identify and manage the (sub)set of an install to run. As such, there may be many configurations per install. Installs may come with a default configuration area but typical startup scenarios involve the runtime attempting to find a more writable configuration location.

Instance (-data) {osgi.instance.area} [@none, @noDefault, @user.home, @user.dir, filepath, url]

Instance locations contain user-defined data artifacts. For example, the Resources plug-in uses the instance area as the workspace location and thus the default home for projects. Other plugins are free to write whatever files they like in this location.

While users can set any of these locations, Eclipse will compute reasonable defaults if values are not given. The most common usecase for setting location is the instance area or, in the IDE context, the workspace. To run the default Eclipse configuration on a specific data set you can specify:

    eclipse -data c:\mydata

More detail

Locations are URLs. For simplicity, file paths are also accepted and automatically converted to file: URLs. For better control and convenience, there are also a number of predefined symbolic locations which can be used. Note that not all combinations of location type and symbolic value are valid. A table below details which combinations are possible. Since the default case is for all locations to be set, valid and writable, some plug-ins may fail in other setups even if they are listed as possible. For example, it is unreasonable to expect a plug-in focused on user data (e.g., the Eclipse Resources plug-in) to do much if the instance area is not defined. It is up to plug-in developers to choose the setups they support and design their function accordingly.

@none

Indicates that the corresponding location should never be set either explicitly or to its default value. For example, an RCP style application which has no user data may use osgi.instance.area=@none to prevent extraneous files being written to disk. @none must not be followed by any additional path segments.

@noDefault

Forces a location to be undefined or explicitly defined (i.e., Eclipse will not automatically compute a default value). This is useful where you want to allow for data in the corresponding location but the Eclipse default value is not appropriate. @noDefault must not be followed by any additional path segments.

@user.home

Directs Eclipse to compute a location value relative to the user's home directory. @user.home can be followed by additional path segments. In all cases, the string "@user.home" is simply replaced with the value of the Java "user.home" System property. For example, setting
    osgi.instance.area=@user.home/myWorkspace
results in a value of
    file:/users/bob/myWorkspace

@user.dir

Directs Eclipse to compute a location value relative to the current working directory. @user.dir can be followed by additional path segments. In all cases, the string "@user.dir" is simply replaced with the value of the Java "user.dir" System property. For example, setting
    osgi.instance.area=@user.dir/myWorkspace
results in a value of
    file:/usr/share/eclipse/myWorkspace

location/value	supports default	file/URL	@none	@noDefault	@user.home	@user.dir
instance	yes	yes	yes	yes	yes	yes (default)
configuration	yes	yes	yes*	yes*	yes	yes
install	no	yes	no	no	yes	yes
user	yes	yes	yes	yes	yes	yes

* indicates that this setup is technically possible but pragmatically quite difficult to manage. In particular, without a configuration location the Eclipse runtime may only get as far as starting the OSGi framework.

Read-only Locations

A location may be specified as a read-only location by appending ".readOnly" to the location property and setting it to the value "true". The following properties can be used to specify their corresponding locations as read-only:

• osgi.configuration.area.readOnly osgi.configuration.area
• osgi.sharedConfiguration.area.readOnly osgi.sharedConfiguration.area
• osgi.instance.area.readOnly osgi.instance.area
• osgi.user.area.readOnly osgi.user.area

Launcher ini file

The eclipse.exe and more generally executables for RCP applications now read their parameters from an associated ini file. This file offers a platform independent way to pass in arguments that previously had to be specified directly on the command line such as vm or vm arguments. Although all parameters can be specified in this file, it recommend for maintainability and consistency across various installations to only specifiy the vm location and the vm arguments in this ini file and use the config.ini file for others.

File format

This file must be named after the executable name (for example, eclipse.exe will read eclipse.ini, whereas launcher.exe will read launcher.ini) and every parameter must be specified on a new line in the file. Here is an example of such a file specifying the vm location and some parameters:

-vm
c:/myVm/java.exe
-vmargs
-Dms40M