Innaworks

mBooster-2-6-4-Doc-Ch3-4-Properties

This page last changed on Nov 19, 2007.

mBooster Properties

This section documents the complete list of properties available in mBooster.

Note

All property names and values are case sensitive. Please take care in defining properties.
To specify a path or directory, forward slashes should be used in place of backward slashes.
When properties are defined in a properties file, they must not contain extra quotes and only one property can be defined per line.
When specifying a property in the command line, do not place extra spaces around '='. E.g. property=value is okay, but property= value or property =value are not.
When properties given in the command line take a PATH, or multiple elements delimited by semi-colons, do not place extra spaces around each element. E.g. property=value1;value2; is okay, but property=value1; value2; is not.

Table Of Contents: Properties

Resource file pathname pattern
Basic Properties
Result Caching Properties
Preverifier Properties
JAR Properties
Class And Interface Merging Properties
Method Inlining Properties
Array Initialization Optimization Properties
- OPT.ARRAY.INIT
Resource Packing Properties
PNG Recompression Properties
M3G Recompression Properties
Redundancy Elimination Optimization Properties
- OPT.VN
Switch Optimization Properties
- OPT.SWITCH
Naming Properties
- FIELD.NAME.OVERLOADING

Resource file pathname pattern

From mBooster 2.5 on, properties specifying resource files accept wildcard patterns.

A wildcard pattern is composed of one or more components separated by the file separator (forward slash '/').

Each component contains one or more characters including the following wildcards as defined below:

'**' matches zero or more components in a pathname.
'*' matches zero or more characters in a component of a pathname.
'?' matches only one letter in a component.

A wildcard pattern is valid if it satisfies all the following conditions:

it does not contain two or more consecutive '/' characters.
if '**' appears in a component, the component cannot contain characters other than '*'.

If a wildcard pattern ends with '/', '**' is automatically appended to the wildcard pattern. For example, '/a/' matches the same set of files as '/a/**'.

Examples:
RESOURCE.PACKING.EXCLUDE=/**/?.jpg would match the following files:
/levels/level4/a.jpg, /levels/a.jpg and /a.jpg.

RESOURCE.PACKING.EXCLUDE=/**.jpg is not a valid wildcard pattern.

Basic Properties

This set of properties specify where mBooster is to locate the input midlet, and where to generate the optimized midlet, and where the midlet entry points are.

Function:
Specifies the directories and JARs where the system library classes are located, delimited by semi-colons. System libraries contain the classes that are resident in the mobile phones.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, it is not allowed to specify directories in this property.

Example:
LIB.CLASSPATH=C:/WTK21/lib/cldcapi11.jar;C:/WTK21/lib/midpapi20.jar

Equivalent command-line parameter:
-l

`APP.CLASSPATH`

Function:
Specifies the directories and JARs or ZIPs where the application classes are located, delimited by semi-colons.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, it is not allowed to specify directories in this property.

Example:
APP.CLASSPATH=C:/Eclipse/Workspace/PingPong/out;C:/Eclipse/Workspace/PacMan.jar

Equivalent command-line parameter:
-a

`MIDLETCLASSES`

Function:
Specifies the main MIDlet classes to optimise from, delimited by semi-colons. These are typically the subclasses of javax.microedition.midlet.MIDlet that are also referenced in MANIFEST.MF, and determine the entry points for the application

Example:
MIDLETCLASSES=com.gameco.PingPongMidlet;com.gameco.PacManMidlet

Equivalent command-line parameter:
-c

See also:
Read Manifest Mode

`REFLECTEDCLASSES`

Function:
Specifies the application classes, and arrays thereof, that can be accessed through the reflection support in the CLDC 1.0/1.1 API, delimited by semi-colons. Any classes identified in this property will not be removed by mBooster even if they are otherwise unused. The no argument constructor in each class will always be preserved. Classes in the library never need to be included in this property.
This property must be set whenever the application contains calls to

public static java.lang.Class java.lang.Class.forName(String)
public void java.lang.Class.newInstance()
public java.lang.Class java.lang.Object.getClass()

Any class named through the forName(String) function, and any class which is instantiated through the newInstance() function, must be specified in this property. Where the application contains calls to the getClass() function and the instance type used in the method call is the type T, then:

If the type T is an array class, then the base element type of that array must be specified in this property
If the type T is a normal non-array class, then it must be specified in this property

Note

The JavaC compiler has the ability to insert calls to the reflection API that may not be apparent to the user. A reference to the class literal (See Java Language Specification 2nd Edition section 15.8.2) for any class will be compiled into a use of reflection that mBooster must be informed of. For example, code of the form

Class myClass = MyMIDlet.class;

will compile into code containing a call to the forName(String) function with the argument "MyMidlet", and so this class must be specified in this property.

mBooster will print a warning or error if it detects that calls to the java.lang.Class.forName(String) function are not covered by this property correctly. See NOCHECK.REFLECTEDCLASSES to disable the error.

Example:
REFLECTEDCLASSES=com.gameco.LargeColorCanvas;GameIcon would be required when the classes com.gameco.LargeColorCanvas, GameIcon are named in the forName(String) function or instantiated through the newInstance() function. We would also need to specifiy the class GameIcon if GameIcon or any of its array classes such as GameIcon[][] are used through the getClass() function.

Equivalent command-line parameter:
-D REFLECTEDCLASSES=

`NOCHECK.REFLECTEDCLASSES`

Function:
This flag can be set ON to disable the check that mBooster makes of usage of the reflection API java.lang.Class.forName(String). The check when enabled will result in mBooster printing an error and exiting if the value of the REFLECTEDCLASSES property is not set correctly.

Valid values are ON and OFF. The default value is OFF, such that the check occurs.

Example:
NOCHECK.REFLECTEDCLASSES=ON

Equivalent command-line parameter:
-D NOCHECK.REFLECTEDCLASSES=

`RESOURCE.PATH`

Function:
Specifies the directories and JARs where resource files are located, delimited by semi colons. Any classfiles in these specified directories and JARs are automatically ignored.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, it is not allowed to specify directories in this property.

Example:
RESOURCE.PATH=C:/Workspace/PingPong/out;C:/Workspace/PacMan.jar

Equivalent command-line parameter:
-r

`READ.MANIFEST`

Function:
Toggles Read Manifest Mode.
Valid values are ON and OFF. The default value is OFF.

Example:
READ.MANIFEST=ON

Equivalent command-line parameter:
-m

`JVM.PLATFORM`

Function:
Specifies the version of Java to expect of the input program.

Valid values are:

Parameter	Comment
J2ME_MIDP	The input program is a J2ME CLDC MIDP midlet
J2ME_DOJA	The input program is a DoJa i-Appli (Please refer to Optimizing DoJa i-Appli)

The default value is J2ME_MIDP.

Example:
JVM.PLATFORM=J2ME_DOJA

Equivalent command-line parameter:
-D JVM.PLATFORM

See also:
Optimizing DoJa i-Appli

`OUTPUT.PATH`

Function:
Specifies the directory or jar file where the output classfiles and resource files are generated. If OUTPUT.PATH specifies a non-existent directory, the said directory will be automatically created.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, it is not allowed to specify a directory in this property.

Example:
OUTPUT.PATH=C:/MyApp_Optimized.jar
OR
OUTPUT.PATH=C:/MyApp_Optimized_dir

Equivalent command-line parameter:
-o

`OUTPUT.STATISTICS.ENABLED`

Function:

Toggles the generation of statistics, printed to the console at the completion of mBooster. When a file is specified through the property OUTPUT.STATISTICS.FILE, this information is also written to the given file.

Valid values are ON and OFF. The default value is OFF.

Note that in the evaluation version of mBooster this is always ON

Example:
OUTPUT.STATISTICS.ENABLED=ON

See also:
Property OUTPUT.STATISTICS.FILE

`OUTPUT.STATISTICS.FILE`

Function:
Specifies the file to output the statistics to.
Note: Please note forward slashes should be used in place of backward slashes

Example:
OUTPUT.STATISTICS.FILE=C:/stats/MyGame.log

Equivalent command-line parameter:
-s

See also:
Property OUTPUT.STATISTICS.ENABLED

`RANDOM.SEED`

Function:
Sets a seed for the random elements of mBooster
Valid values are: positive integers. Setting the value to -1 will use the current time as the random seed, giving a different seed for each execution of mBooster. The default value is a constant within mBooster.

For a given random seed, mBooster's behavior will be completely reproducible, but varying the seed can lead to differences in the output, generally of up to +/- 100 bytes.

Example:
RANDOM.SEED=123

Equivalent command-line parameter:
-D RANDOM.SEED=

`FAST`

Function:
When this property is enabled mBooster uses slightly faster algorithms in steps 14 and 40, at the cost of achieving slightly less size reduction. Typically <100 bytes change in size with 10% to 40% improvement of overall execution time.

Example:
FAST=ON

Equivalent command-line parameter:
-D FAST=

Result Caching

This set of properties specifies the behavior of mBooster Result Caching.

`CACHE.ENABLED`

Function:
When set to ON, mBooster will cache the intermediate results to speed up future executions of mBooster.
Valid values are ON and OFF. The default value is ON.

Please note that mBooster Result Caching is disabled in Evaluation Version. This property therefore has no effect.

Example:
CACHE.ENABLED=OFF

Equivalent command-line parameter:
-D CACHE.ENABLED=

`CACHE.PATH`

Function:
When CACHE.ENABLED is set to ON, this property specifies the path of the mBooster cache directory. This property overrides the Windows environment variable mBooster_cache_path.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, this property is ignored

Example:
CACHE.PATH=Z:/mBooster_cache

Equivalent command-line parameter:
-D CACHE.PATH

`CACHE.SIZE.LIMIT`

Function:
When CACHE.ENABLED is set to ON, this property specifies the size of the cache in MB. Specifically if the cache exceeds the size specified, oldest entries in the cache will be removed. This property overrides the Windows environment variable mBooster_cache_size_limit.
Note: For mBooster Remote Access Client, this property is ignored

Valid values are -1, 0, and positive integers.
When set to -1, there is no cache size limit.
When set to 0, all entries in the cache will be removed whenever the cache is cleaned up.

Example:
CACHE.SIZE.LIMIT=100

Equivalent command-line parameter:
-D CACHE.SIZE.LIMIT

Preverifier

This set of properties specifies if and how the optimized midlet is preverified to generate the stack map information.

`PREVERIFIER.ENABLED`

Function:
When set to ON, mBooster will generate stackmap information in the output classfiles, using the preverifier as specified by PREVERIFIER.METHOD.
Valid values are ON and OFF. The default value is ON.

Example:
PREVERIFIER.ENABLED=OFF

Equivalent command-line parameter:
-D PREVERIFIER.ENABLED=

`PREVERIFIER.METHOD`

Function:
When PREVERIFIER.ENABLED is set to ON, this parameter specifies which preverifier is used to generate the stackmap information
The allowed values are:

Value	Notes
`INTERNAL`	(recommended) mBooster's integrated preverifier that typically generates more compact stack maps than Sun's preverifier
`EXTERNAL`	External preverifier specified in `PREVERIFIER.EXE.PATH`. This option is disabled in the Evaluation Version. The property `PREVERFIER.EXE.PATH` must be set to specify the path of the preverifier executable.

The default value is INTERNAL.

Example:
PREVERIFIER.METHOD=INTERNAL

Equivalent command-line parameter:
-D PREVERIFIER.METHOD=

`PREVERIFIER.EXE.PATH`

Function:
When PREVERIFIER.METHOD is set to EXTERNAL, the value of this property must point to the location of the Sun preverifier, or an equivalent executable.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, this property is ignored

Example:
PREVERIFIER.EXE.PATH=C:/java/WTK21/bin/preverify.exe

Equivalent command-line parameter:
-D PREVERIFIER.EXE.PATH=

JAR compressor

If the optimized midlet is to be output to a JAR file, this set of properties specifies how the JAR file is generated.

`JAR.METHOD`

Function:
When the OUTPUT.PATH is a .JAR file, this property defines the JAR compressor to compress the files into the JAR file.
The allowed values are:

Value	Notes
`MBOOSTERZIP`	(recommended) Compress using the integrated mBoosterZip compressor. mBoosterZip typically delivers the highest compression ratio.
`STANDARD`	Compress using the standard ZIP library as implemented by J2SE
`7ZIP`	Compress using 7-zip with the parameter -mx9. This option is disabled in the Evaluation Version. The property `7ZIP.EXE.PATH` must be set to specify the path of the 7-zip executable.

The default value is MBOOSTERZIP.

Example:
JAR.METHOD=STANDARD

Equivalent command-line parameter:
-D JAR.METHOD=

`MBOOSTERZIP.MAX.CHAIN.LENGTH`

Function:
This property defines the scope of the search function in the integrated mBoosterZip compressor while searching for duplicates. A larger value will generate a higher compression ratio at the cost of a decrease of run-time performance.
Valid values are 128 to 32768. Default value is 8000. Other recommended values are 2000, 4000, 16000.

Example:
MBOOSTERZIP.MAX.CHAIN.LENGTH=16000

Equivalent command-line parameter:
-D MBOOSTERZIP.MAX.CHAIN.LENGTH=

See also:
mBoosterZip is also available as a stand-alone program. This property to the equivalent -max_chain_length command line parameter in the standalone mBoosterZip.

`7ZIP.EXE.PATH`

Function:
Specifies the path of the 7ZIP executable.
Note: Please note forward slashes should be used in place of backward slashes
Note: For mBooster Remote Access Client, this property is ignored

Example:
7ZIP.EXE.PATH=C:/program files/7-zip/7za.exe

Equivalent command-line parameter:
-D 7ZIP.EXE.PATH=

Class And Interface Merging

This set of properties configures Class And Interface Merging.

`OPT.CLASS.MERGING`

Function:
Switch for Class And Interface Merging
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.CLASS.MERGING=ON

Equivalent command-line parameter:
-D OPT.CLASS.MERGING=

`CLASS.MERGING.NOCHECK.CLINIT.ORDER`

Function:
By merging two classes, the execution order of the class initializers of the two classes may be affected. mBooster by default will check that the class initializers are not sensitive to the order of execution, prior to performing class merging.

When this property is set to OFF mBooster checks to see if the order of execution of the two class initializers would affect the behavior of the application, specifically

Complex interactions between the two class initializers
Side effects in the class initializers in either class

mBooster detects potential complex interactions between the class initializers and side effects in the class initializers. mBooster will not merge the involved classes if there is the slightest suspicion; otherwise the optimized application may not correctly preserve the behavior. The algorithm for determining such conditions is conservative. If you are confident that such conditions do not occur, you could help mBooster by setting this property to ON to increase the number of class merging opportunities.

Well written Java applications typically do not rely on the order of execution of class initializers, and therefore can have this flag safely set to ON.
However it is reasonable for your application to initialize the contents of a static field by reading the contents of a field in a different class. This in fact can lead to a dependency between the class initializers of the two classes, and its possible that merging the two classes together would cause one of the fields to contain an incorrect value. To protect against this, mBooster would not merge classes in this situation unless this property is set to ON.

Complex interactions between class initializers
In theory (and sometimes accidentally in practice) you can produce class initializers that exhibit different behavior depending on whether other classes have already been initialized (i.e. race condition), or are in the process of being initialized. This is typically unintended behavior, and represent a latent defect in the application.

Side effects
When the class initializers of two classes have a side effect, for example writing to the network/database/screen, it is generally not safe to merge the said classes, because the side effects might interfere with each other.

Valid values are ON and OFF. The default value is OFF.

Example:
CLASS.MERGING.NOCHECK.CLINIT.ORDER=ON

Equivalent command-line parameter:
-D CLASS.MERGING.NOCHECK.CLINIT.ORDER=

`CLASS.MERGING.NOCHECK.CLASS.SYNC`

Function:
When this is set to ON, class merging occurs without checking that there are no static synchronized methods present in the classes to be merged.

A synchronized static method will synchronize on the class in which the method is declared. When this property is set to OFF, mBooster will ensure that the two classes to be merged do not have synchronized static methods. This check removes the possibility for mBooster to introduce a synchronization deadlock, or a new race condition. If your application is single-threaded you should be able to safely this property to ON.

Valid values are ON and OFF. The default value is OFF.

Example:
CLASS.MERGING.NOCHECK.CLASS.SYNC=ON

Equivalent command-line parameter:
-D CLASS.MERGING.NOCHECK.CLASS.SYNC=

`CLASS.MERGING.NOCHECK.CLINIT.UNCAUGHT.EXCEPTIONS`

Function:
When this is set to ON, class merging occurs without checking that the class initializers involved will never throw an uncaught exception. For most applications this is fine to leave on as it is very rare for a class initializer to throw an exception.

Valid values are ON and OFF. The default value is ON.

Example:
CLASS.MERGING.NOCHECK.CLINIT.UNCAUGHT.EXCEPTIONS=OFF

Equivalent command-line parameter:
-D CLASS.MERGING.NOCHECK.CLINIT.UNCAUGHT.EXCEPTIONS=

`CLASS.MERGING.NOCHECK.ARRAY.STORE`

Function:
When this is set to OFF, prior to merging two classes, mBooster will check for the possibility of an java.lang.ArrayStoreException involving an array of one of the two classes. As a result of this conservative check mBooster could potentially miss class merging opportunities that are in fact safe.

It is safe to set this property to ON if the application never throws an ArrayStoreException. Setting this property to ON will increase the opportunities for class merging, and may result in smaller JAR files.

Valid values are ON and OFF. The default value is ON.

Example:
CLASS.MERGING.NOCHECK.ARRAY.STORE=OFF

Equivalent command-line parameter:
-D CLASS.MERGING.NOCHECK.ARRAY.STORE=

`CLASS.MERGING.NOCHECK.CHECKCAST`

Function:
When this is set to OFF, prior to merging two classes, mBooster will check for the possibility of a java.lang.ClassCastException as a result of casting an instance of the two classes to a class in the hierarchy of the other. As a result of this conservative check mBooster could potentially miss class merging opportunities that are in fact safe.

It is safe to set this property to ON if the application never throws a ClassCastException. Setting this property to ON will increase the opportunities for class merging, and may result in smaller JAR files.

Valid values are ON and OFF. The default value is ON.

Example:
CLASS.MERGING.NOCHECK.CHECKCAST=OFF

Equivalent command-line parameter:
-D CLASS.MERGING.NOCHECK.CHECKCAST=

`CLASS.MERGING.MAX.CLASS.SIZE`

Function:
When this property is set to a positive value, Class Merging Optimization will never merge classes that can form a class whose file size is greater than this value in bytes. This property might be useful when targeting devices who have a limit on the maximum size of a single class, such as the Nokia 7210.
Note:

Placing a limit on the maximum class size will usually reduce the amount of size reduction provided by class merging.
If an input class file is larger than the limit, it will not be merged with any other classes, but could still be larger than the limit when output from mBooster

When this property is set to 0 there is no limit to merged class size. The default value is 0 (no limit).

Example:
CLASS.MERGING.MAX.CLASS.SIZE=65536

Equivalent command-line parameter:
-D CLASS.MERGING.MAX.CLASS.SIZE=

`CLASS.MERGING.EXCLUDE`

Function:
Specifies a list of class names separated by semi-colons, identifying classes we must prevent from merging with any other class. The specified classes will not be the source or destination class in any merge.

Wildcards are not supported in the class names. Invalid names will be ignored.

Example:
CLASS.MERGING.EXCLUDE=game.a;game.b;game.util.a Will ensure that no classes are ever merged with game.a, game.b, or game.util.a

Equivalent command-line parameter:
-D CLASS.MERGING.EXCLUDE=

`CLASS.MERGING.MODE`

Function:
Specifies whether class merging optimization operates in Simple mode or Advanced mode.

Valid values are 1 for Simple mode and 2 for Advanced mode. The default value is 1.

Example:
CLASS.MERGING.MODE=2

Equivalent command-line parameter:
-D CLASS.MERGING.MODE=

`CLASS.MERGING.SIMPLE.LEVEL`

Function:
When Class Merging Optimization is operating in Simple mode this property determines how aggressive the class merging algorithm is.

Valid values are 0(least agressive) to 10(most agressive). The default value is 8.
When this property is set to 0, class merging will not result in increase in heap memory usage.

Example:
CLASS.MERGING.SIMPLE.LEVEL=10

Equivalent command-line parameter:
-D CLASS.MERGING.SIMPLE.LEVEL=

`CLASS.MERGING.SIMPLE.AVOID.CLASSES`

Function:
When Class Merging Optimization is operating in Simple mode this property specifies a list of classes that we will not merge unless the heap usage for instances of those classes will not increase as a result of being merged. This property is commonly used to list classes for which the user knows there are a large number of concurrent instances, such that any increase in the heap usage of those classes would have a significant effect on the application.

Example:
CLASS.MERGING.SIMPLE.AVOID.CLASSES=com.gameco.Monster;com.gameco.Ghost

Equivalent command-line parameter:
-D CLASS.MERGING.SIMPLE.AVOID.CLASSES=

`CLASS.MERGING.ADVANCED.MAX.HEAP.INCREASE`

Function:
When Class Merging Optimization is operating in Advanced mode this property determines the maximum allowable heap usage increase in bytes.

When this property is set to -1 there is no limit in heap usage increase. The default value is -1 (no limit).

Example:
CLASS.MERGING.ADVANCED.MAX.HEAP.INCREASE=40960 specifies a maximum allowable heap usage increase of 40kB

Equivalent command-line parameter:
-D CLASS.MERGING.ADVANCED.MAX.HEAP.INCREASE=

`CLASS.MERGING.ADVANCED.MAX.INSTANCES`

Function:
When Class Merging Optimization is operating in Advanced mode this property specifies the maximum number of concurrent instances for each class.

The format of the value is list of class instance pair delimited by semicolons. Each class instance pair is the name of the class, followed by a colon, followed by an integer specifying the number of instances.

If the number is -1, the class is excluded from class merging where it would result in a heap memory usage increase for the instances of the said class.
If the number is -2, the class is never merged with any other class. (Equivalent to CLASS.MERGING.EXCLUDE)

Please note the value specified in this property overrides the value specified in the MBOOSTER_MAX_INSTANCES field in the corresponding class.

Example:
CLASS.MERGING.ADVANCED.MAX.INSTANCES=com.innaworks.MonsterFactory:1; com.innaworks.Monster:500;com.innaworks.Ghost:-1 specifies that

There is a maximum of one concurrent instance of com.innaworks.MonsterFactory
There is a maximum of 500 concurrent instances of com.innaworks.Monster
com.innaworks.Ghost is excluded from class merging

Equivalent command-line parameter:
-D CLASS.MERGING.ADVANCED.MAX.INSTANCES=

Method Inlining

This set of properties configures Method Inlining.

`OPT.METHOD.INLINING`

Function:
Switch for Method Inlining
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.METHOD.INLINING=ON

Equivalent command-line parameter:
-D OPT.METHOD.INLINING=

`METHOD.INLINING.BYTES.THRESHOLD`

Function:
This property sets the approximate upper limit in bytes for the length of a method than can result from method inlining. mBooster will not inline a method call if it would lead to the existence of a method whose length is greater than this limit.

Valid values are integers greater than 0 and less than or equal to the default limit 32767.
The default value is 32767

Certain J2ME virtual machines are known to degrade performance if a method size exceeds a certain limit. This property provides a mechanism to avoid performance degradation due to method inlining.

Example:
METHOD.INLINING.BYTES.THRESHOLD=8192 will force mBooster to not inline any method call that would lead to the calling method being more than 8192 bytes long.

Equivalent command-line parameter:
-D METHOD.INLINING.BYTES.THRESHOLD=

`METHOD.INLINING.BYTECODES.THRESHOLD`

Function:
This property sets the approximate upper limit in bytecodes for a method than can result from method inlining. mBooster will not inline a method call if it would lead to the existence of a method with the number of bytecodes greater than this limit.

Valid values are integers greater than 0 and less than or equal to the default limit 65535.
The default value is 65535

Certain J2ME virtual machines are known to degrade performance if a method size exceeds a certain limit. This property provides a mechanism to avoid performance degradation due to method inlining.

Example:
METHOD.INLINING.BYTECODES.THRESHOLD=4096 will force mBooster to not inline any method call that would lead to the calling method having more than 4096 bytecodes.

Equivalent command-line parameter:
-D METHOD.INLINING.BYTECODES.THRESHOLD=

Array Initialization Optimization

This set of properties configures Array Initialization Optimization.

`OPT.ARRAY.INIT`

Function:
Switch for Array Initialization Optimization
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.ARRAY.INIT=ON

Equivalent command-line parameter:
-D OPT.ARRAY.INIT=

Resource Packing Optimization

This set of properties configures Resource Packing optimization.

`OPT.RESOURCE.PACKING`

Function:
Switch for Resource Packing optimization.
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.RESOURCE.PACKING=ON

Equivalent command-line parameter:
-D OPT.RESOURCE.PACKING=

`RESOURCE.PACKING.MODE`

Function:
This property selects which mode to perform resource packing in. The modes supported are Load-On-Demand Mode (previously Classic Mode), Preload Mode, and Profiling Mode.

Valid values are:

1 For Load-On-Demand Mode
2 For Preload Mode
3 For Profiling Mode
The default value is 1.

Example:
RESOURCE.PACKING.MODE=2

Equivalent command-line parameter:
-D RESOURCE.PACKING.MODE=

`RESOURCE.PACKING.PARSE.COMPLEX.PATHS`

Function:
When this is set to ON, the optimized application parses the path identifying each resource at runtime, so that

The paths can contain backslashes,
The paths can contain the special directories '.' and '..',
The paths do not have to be given as absolute (i.e. the first character is '/')

When this is set to OFF, the optimized application will be of a further reduced size and increased performance. However it will only work correctly if every path identifying a resource is given as having no backslashes, no special directories, and as an absolute path only.

Valid values are ON and OFF. The default value is ON.

Example:
RESOURCE.PACKING.PARSE.COMPLEX.PATHS=OFF

Equivalent command-line parameter:
-D RESOURCE.PACKING.PARSE.COMPLEX.PATHS=

`RESOURCE.PACKING.MAX.PACK.SIZE`

Function:
This property sets the upper limit in bytes for the size of packed resource files that mBooster will produce. Generally setting this property to a larger value would result in a smaller optimized JAR file; however the optimized midlet will be slower to access the resource files, and have a higher heap usage.

Valid values are:

Positive integer
0 indicating no limit.
The default value is 0 (no limit).

Example:
RESOURCE.PACKING.MAX.PACK.SIZE=10240 limits the packed resource files to 10240 bytes.

Equivalent command-line parameter:
-D RESOURCE.PACKING.MAX.PACK.SIZE=

`RESOURCE.PACKING.PACK.FILE.DIR`

Function:
This property specifies in which directory within the JAR file or resource path to place the resource pack files.
The default is '/', or the root of the .jar file. Some mobile phones are unable to read from resource files placed in the root of the .jar file, in order to make the application runnable on these phones the user must provide a non-empty directory to place resource pack files in. An error will be thrown if the directory conflicts with the name of an existing resource file, or if the directory name has the suffix ".class".
Note: Please note forward slashes should be used in place of backward slashes.

Example:
RESOURCE.PACKING.PACK.FILE.DIR=res places the packed resource files in a directory named 'res'.

Equivalent command-line parameter:
-D RESOURCE.PACKING.PACK.FILE.DIR=

`RESOURCE.PACKING.EXCLUDE`

Function:
This property allows the user to explicitly exclude one or more resource files from Resource Packing optimization. The form of the property should be one or more paths specified as a resource file pathname pattern, delimited by semicolons. Each path must be given relative to the base dir for resources (or the root of the .jar file).
Note: Please note forward slashes should be used in place of backward slashes

By default mBooster will not pack the following resource files; so they do not need to be specified through this property:

The manifest file META-INF/MANIFEST.MF
When Read Manifest Mode is enabled, the icon files referenced in the manifest file. See Read Manifest Mode for details.

Example:
RESOURCE.PACKING.EXCLUDE=res/**/icon.jpg;res/splash.png explicitly excludes res/splash.png and all files named icon.jpg in /res or its subdirectories.

Equivalent command-line parameter:
-D RESOURCE.PACKING.EXCLUDE=

`RESOURCE.PACKING.CREATEIMAGE.RELATIVEPATH.DIR`

Function:
When RESOURCE.PACKING.PARSE.COMPLEX.PATHS is set to ON, the path specified by this property is used to convert any relative paths passed to the public static javax.microedition.lcdui.Image javax.microedition.lcdui.Image.createImage(java.lang.String) into absolute paths. This property should be set when the user knows there are relative paths passed to the createImage(java.lang.String) function, and the behavior of the target platform is known.
Note: Please note forward slashes should be used in place of backward slashes

Tips
It is not recommended to pass in a relative path to the createImage() method due to the unspecified and inconsistent behavior across different handsets. Where practical it is recommended to modify the source code to pass in the equivalent absolute path.

Default value is <empty>. I.e. all paths must be absolute.

Example:
RESOURCE.PACKING.CREATEIMAGE.RELATIVEPATH.DIR=com/innaworks/mygame

Equivalent command-line parameter:
-D RESOURCE.PACKING.CREATEIMAGE.RELATIVEPATH.DIR

`RESOURCE.PACKING.PRELOAD.GROUP.<N>`

Function:
When Resource Packing Optimization is operating in Preload Mode, each of these properties for <N> = 1 .. 99 specify a preload group. The form of each property should be one or more paths specified as a resource file pathname pattern, delimited by semicolons. Each path must be given relative to the base dir for resources (the root of the .jar file).
Note: Please note forward slashes should be used in place of backward slashes

Example:
RESOURCE.PACKING.PRELOAD.GROUP.5=res/L5*

Equivalent command-line parameter:
-D RESOURCE.PACKING.PRELOAD.GROUP.<N>=

`RESOURCE.PACKING.PRELOAD.HAS.DEFAULT.GROUP`

Function:
When Resource Packing Optimization is operating in Preload Mode, the files not excluded by RESOURCE.PACKING.EXCLUDE and not included in any of the preload groups as specified by RESOURCE.PACKING.PRELOAD.GROUP.<N> properties can be treated in two ways:

When this property is set to OFF, they are excluded from resource packing
When this property is set to ON, they are treated collectively as a preload group.

Valid values are ON and OFF. The default value is OFF.

Example:
RESOURCE.PACKING.PRELOAD.HAS.DEFAULT.GROUP

Equivalent command-line parameter:
-D RESOURCE.PACKING.PRELOAD.HAS.DEFAULT.GROUP=

`RESOURCE.PACKING.PRELOAD.SYNC`

Function:
When Resource Packing Optimization is operating in Preload Mode and this property is set to OFF, the optimized JAR file size is further reduced at the cost of not suppporting multi-threaded resource file access.

Valid values are ON and OFF. The default value is ON.

Example:
RESOURCE.PACKING.PRELOAD.SYNC=OFF

Equivalent command-line parameter:
-D RESOURCE.PACKING.PRELOAD.SYNC=

PNG Recompression

This set of properties configures PNG Recompression optimization.

`OPT.PNG.RECOMPRESSION`

Function:
Switch for PNG Recompression optimization.
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.PNG.RECOMPRESSION=OFF

Equivalent command-line parameter:
-D OPT.PNG.RECOMPRESSION=

`PNG.RECOMPRESSION.MAX.IDAT.DATA.SIZE`

Function:
Sets an integer size for the maximum amount of data in bytes that PNG recompression will allow in a single IDAT data chunk. Some mobile handsets may have limits in their handling of the PNG format with regards to the size of IDAT chunks they can load.
Valid values are positive integer values, 0 specifies no limit. The default value is 0 (no limit).

Example:
PNG.RECOMPRESSION.MAX.IDAT.DATA.SIZE=4096

Equivalent command-line parameter:
-D PNG.RECOMPRESSION.MAX.IDAT.DATA.SIZE=

`PNG.RECOMPRESSION.KEEP.ALL.CHUNKS`

Function:
Switch for forcing the PNG recompressor to keep all chunks found in the input PNG files. When this is off, only the compulsory chunks and the tRNS (transparency) chunk are kept by the recompressor.
Valid values are: ON and OFF. The default value is OFF.

Example:
PNG.RECOMPRESSION.KEEP.ALL.CHUNKS=ON

Equivalent command-line parameter:
-D PNG.RECOMPRESSION.KEEP.ALL.CHUNKS=

`PNG.RECOMPRESSION.EXCLUDE`

Function:
This property allows the user to explicitly exclude one or more resource files from PNG Recompression. The form of the property should be one or more paths specified as a resource file pathname pattern, delimited by semicolons. Each path must be given relative to the base dir for resources (or the root of the .jar file).
PNG Recompression will already ignore any non-PNG files, regardless of the extension, but this property is useful if specific files are unsafe to be recompressed, such as when the application depends on the size of the PNG file.
Note: Please note forward slashes should be used in place of backward slashes

Example:
PNG.RECOMPRESSION.EXCLUDE=myimage.png;images/**/icon.png

Equivalent command-line parameter:
-D PNG.RECOMPRESSION.EXCLUDE=

M3G Recompression

This set of properties configures M3G Recompression optimization.

`OPT.M3G.RECOMPRESSION`

Function:
Switch for M3G Recompression optimization.
Valid values are: ON and OFF. The default value is OFF.

Example:
OPT.M3G.RECOMPRESSION=ON

Equivalent command-line parameter:
-D OPT.M3G.RECOMPRESSION=

`M3G.RECOMPRESSION.NO.COMPRESS.EXTREF.SECTION`

Function:
Switch that when set to ON will tell the M3G recompressor to not compress the external references section when it is present in any M3G file to be recompressed.
Valid values are: ON and OFF. The default value is OFF.

Example:
M3G.RECOMPRESSION.NO.COMPRESS.EXTREF.SECTION=ON

Equivalent command-line parameter:
-D M3G.RECOMPRESSION.NO.COMPRESS.EXTREF.SECTION=

`M3G.RECOMPRESSION.NO.COMPRESS.SCENE.SECTIONS`

Function:
Switch when set to ON will tell the M3G recompressor to not compress the scene sections found in any M3G file to be recompressed.
Valid values are: ON and OFF. The default value is OFF.

Example:
M3G.RECOMPRESSION.NO.COMPRESS.SCENE.SECTIONS=ON

Equivalent command-line parameter:
-D M3G.RECOMPRESSION.NO.COMPRESS.SCENE.SECTIONS=

`M3G.RECOMPRESSION.NO.MERGE.SCENE.SECTIONS`

Function:
Switch that when set to ON will tell the M3G recompressor to not merge the scene sections found in any M3G file to be recompressed.
Valid values are: ON and OFF. The default value is OFF.

Example:
M3G.RECOMPRESSION.NO.MERGE.SCENE.SECTIONS=ON

Equivalent command-line parameter:
-D M3G.RECOMPRESSION.NO.MERGE.SCENE.SECTIONS=

`M3G.RECOMPRESSION.EXCLUDE`

Function:
This property allows the user to explicitly exclude one or more resource files from M3G Recompression. The form of the property should be one or more paths specified as a resource file pathname pattern, delimited by semicolons. Each path must be given relative to the base dir for resources (or the root of the .jar file).
M3G Recompression will already ignore any non-M3G files, regardless of the extension, but this property is useful if specific files are unsafe to be recompressed, such as when the application depends on the size of the M3G file.
Note: Please note forward slashes should be used in place of backward slashes

Example:
M3G.RECOMPRESSION.EXCLUDE=3dworld.m3g;res/no-compress/**/level?.m3g

Equivalent command-line parameter:
-D M3G.RECOMPRESSION.EXCLUDE=

Redundancy Elimination Optimization

This set of properties configures Redundancy Elimination optimization.

`OPT.VN`

Function:
Switch for Redundancy Elimination optimization.
Valid values are: ON and OFF. The default value is OFF.

Example:
OPT.VN=ON

Equivalent command-line parameter:
-D OPT.VN=

Switch Optimization

This set of properties configures Switch Optimization.

`OPT.SWITCH`

Function:
Switch for Switch Optimization.
Valid values are: ON and OFF. The default value is ON.

Example:
OPT.SWITCH=OFF

Equivalent command-line parameter:
-D OPT.SWITCH=

Naming

This set of properties configures the naming and renaming aspects of mBooster.

`FIELD.NAME.OVERLOADING`

Function:
Switch for how names for renamed/added fields are chosen. When set to ON we allocate names such that no two fields in the same class share the same name, even where their type is different. This property may need to be set to ON for some target emulators/devices.
Valid values are: ON and OFF. The default value is ON.

Example:
FIELD.NAME.OVERLOADING=OFF

Equivalent command-line parameter:
-D FIELD.NAME.OVERLOADING=

— Previous page – Contents – Next page —