WO2001097013A2 - Method for managing classes for an object-oriented programming language with dynamic resolution and tool for generating native structures from java binaries implementing said method - Google Patents

Abstract

The invention concerns a method for managing classes for an object-oriented language with dynamic class resolution, which consists in transforming the dynamic class resolution for a group of self-contained classes into a static resolution system. The invention also concerns a tool for generating native structures from object binaries implementing said method

Description

 CLASS MANAGEMENT METHOD FOR A LANGUAGE OF

OBJECT-ORIENTED PROGRAMMING WITH DYNAMIC RESOLUTION AND

TOOL FOR GENERATING NATIVE STRUCTURES SINCE

JAVA BINARIES IMPLEMENTING THIS PROCESS

DESCRIPTION

Technical area

The invention relates to a class management method for an object-oriented programming language with dynamic resolution and to a tool for generating native structures from Java binaries implementing this method.

State of the art

For a programming language "being object oriented" means that apart from the predefined basic types such as numbers or characters, everything is object. The programs are made up of assemblies of the software components that are the objects. The object is the union in a single entity of a data structure and algorithms allowing to manipulate this data structure. This idea is opposed to that of conventional programming where data and processing are separated.

The field of the invention is that of object oriented languages with dynamic resolution, more particularly that of the Java language. Java language

The Java language is a high level programming language, object oriented, simple, interpreted, secure, portable, and dynamic. It eliminates faults and takes up the best aspect of object oriented languages such as C ++, while simplifying its use (memory, for example, is no longer managed by the developer). The portability of the language is ensured by its execution environment, the Java virtual machine, which is adapted to the system on which the tasks and applications developed in this language will be executed. Its development has been favored by the rise of the Internet network, the abstraction of the execution platform being adapted to this heterogeneous network.

The object approach (of a system) in IT differs from the procedural approach (cutting a task into a set of sub-tasks). Objects exchange messages and interact in order to achieve the required functionality.

An object can be defined as follows:

• An object is an identified and named entity.

• The state of this entity is defined by a set of attributes:

• A set of operations (methods) determine the behavior of the object. "An object is an instance of class

• A class is a data type abstract defining attributes and methods. These properties are common to instances of the class.

• The methods and attributes of an object class form the properties of the object class.

The main object concepts are described below:

• Encapsulation: this concept hides the details of implementing an object by defining an interface (external view of the object).

• Inheritance: this concept defines a transfer of attributes and methods from one class to another class (subclass). A class can specialize in a subclass. A subclass can inherit from several classes (multi-inheritance).

• Aggregation: this concept makes it possible to define objects composed of other objects.

The Java language uses object concepts and a syntax very close to the C / C ++ language. Some specificities of the Java language are considered below:

• Virtual machine and runtime environment: to ensure portability of Java sources (and binaries), binaries run in the Java virtual machine, which is an abstraction layer between the binary and the hardware environment (microprocessor , communication ports, ...)

• Interfaces and single inheritance: for performance reasons, multi-inheritance is not supported.

However a notion of interface (abstract class whose one cannot inherit) is introduced, an interface used to describe a set of methods. An object class can implement an interface as long as it defines all of the methods described by the interface.

• Packages: the classes are, possibly, grouped by packages ("packages"), a package consisting of a grouping of classes by affinities.

• Standard Java packages: with the Java virtual machine, a certain number of basic packages are defined on which Java developers can rely to design portable applications. The main ones are:

- Java.lang: package containing the basic language classes (character strings, ...)

- Java. util: package defining utility classes such as hash tables

- Java.io: package providing functionalities, input / output type (files, ...) - Java.net: package concerning the network functionalities of Java.

Each of the properties of an object class has a set of attributes. One of these attributes is the visibility of the property:

- Private access: only the class can access its property

- Package access ("protected package"): all object classes in the package can access the property.

- Protected access ("protected"): the property is not accessible only from the object class and its subclasses. - Public access: access to the property is open to all object classes.

Java virtual machines only load the object classes used by an application. The first time you use a class, it is defined internally and made available to the application.

Each class has a table of classes that it will use. When using one of these classes, it requests a reference to the internal structure of the class in order to be able to use it. This process, for performance reasons, is performed only once per class used. This is done by replacing an operation requiring class resolution with an equivalent operation based on the principle that the class is resolved (ie: known).

Embedded systems

Embedded systems are software systems providing a service determined in advance. These systems run in a hardware environment dedicated to the functionality achieved.

The digital television decoders are based on a real-time on-board system as well as an electronic box, all designed to provide pay television services.

The "Media-Highway" system as well as associated development tools provide the application means to develop interactive services revolving around the profession of digital television, such as program selection services. In its Java version ("MediaHighway

Virtual Machine "), the" MediaHighway "system includes a Java virtual machine, associated development tools and a set of interactive services.

The digital television systems developed by Canal + are intended for diverse customers and take place in machines of relatively different designs from each other, the choice of hardware components being left to the manufacturer.

The "MediaHighway +" system (MHPLUS) is an embedded digital television system whose applications are designed in Java language.

The choice of the Java language is motivated on the one hand because of the potential of this language and on the other hand from the abstraction which is made at the level of the material environment.

Java sources are compiled to produce the associated Java binaries. The binaries produced appear as files. Each package has a directory. Each class corresponds to a file describing the class. This file is located in the directory associated with the class package. The software kernel, on which the embedded Java virtual machine is based, has a software interface for accessing a file system. This file system is capable of handling files whose definitions can be found in various places. One of these locations is the binary itself. In the binary data, a whole set of linked structures forms the so-called "ROM" file system (since it ends up in the non-writable ROM memory of the target machine). Java binaries are ultimately found in the "ROM" file system of the file manager. The directory and file tree corresponding to the packages and. Java binaries classes are directly reproduced in the "ROM" file system. To do this, a tool allows you to generate source code in C language. The source code once compiled defines the tree structure relating to Java binaries. The result of this compilation, once integrated into the final binary, provides the Java virtual machine with the class definitions necessary for its operation.

The embedded virtual machine has a class manager, which is an application module responsible for the database of Java classes used.

When an object class is necessary for the operation of an application set, and this class is not yet defined, the virtual machine

Java does the following to make the class available:

1. Loading the description of the class (binary file resulting from the compilation of a Java source), 2. Definition, if necessary, of its parent class (which amounts to applying these same steps for the superclass),

3. Initialization of the class (execution of Java code defined in the source of the class).

If all these steps go without errors, the class manager provides the virtual machine with the internal definition of the class.

In the general case, the description of the class is loaded from the file system.

The constraints linked to this operating mode are very strong in embedded environments, often quite limited in resources such as memory: • All the classes used must be loaded, in particular the basic classes of the Java language, which implies a significant loss of time. • The space occupied in memory is considerable since to the files in ROM memory, data structures are added, forming the internal definition of the class, these data structures being in RAM memory.

The subject of the invention is an alternative solution to the solution described above for providing classes in environments poor in memory and in processing power, by delocalizing the maximum of the processing carried out when loading the classes used at the start of the system, and minimizing the effects related to the constraints cited. Statement of the invention

The invention relates to a class management method for an object oriented language based on a dynamic resolution of object classes, characterized in that the resolution of at least one dynamic class is transformed, for a group of autonomous classes. , in static resolution. Advantageously in said method, used in a Java virtual machine for a set of autonomous classes, we include the native structure exploited directly by the kernel, of these classes as binary data of the virtual machine (we thus free ourselves from the constraint files) . We do some of the solving work, and we optimize the memory resources of the system.

Advantageously in said method, used in an embedded system, we include the native structure, exploited directly by the Java kernel, of these classes as binary data of the virtual machine in a form implying an optimization (reduction of the operating cost of all autonomous classes) of the memory resources of the system as well as an optimization in speed of the execution of the bytecode of the class methods.

You can create source files in native language describing the native structures corresponding to the autonomous set of classes. We can split the autonomous set of classes into subsets corresponding to Java packages, these subsets not being autonomous individually, and establish rules for naming symbols (name + description of structures) so as to be able to reference a class of a package from a class of another package. Within the framework of the description of the methods and more particularly within the framework of the description of the bytecode of the methods, one can replace the bytecode requiring the resolution of an entity by the bytecode realizing the same functionality but which starts from the principle that the entity is resolved.

The invention also relates to a tool for generating native structures from Java binaries implementing the method.

The method of the invention finds particular utility in systems poor in memory resource, such as digital television decoders.

Brief description of the figures

Figure 1 illustrates a known art binary generation process. Figure 2 illustrates a binary generation process according to the invention.

Figure 3 illustrates structures associated with Java classes. Detailed description of embodiments of the invention

The solution adopted by the method of the invention consists in offshoring the maximum of the processing carried out when loading the classes used at the start of the system, while minimizing the effects linked to the constraints cited.

Rather than integrate the class descriptions generated during Java compilation step, we integrate the structures descriptions ^internal classes used by the manager. The class manager, at system startup, preloads all the classes defined in this way and executes the associated Java initialization code. The loading of these classes is simplified for the class manager, since the internal structures of the classes are already defined.

The entire structure is located in the ROM memory. Only the information likely to be modified during the execution of applications is found delocalized in the RAM memory.

The method of the invention, to accomplish the creation of the internal structure of a class, is such that:

• The internal structures of the classes to be used by it are known during the integration of the binary, direct references to these classes being used.

• The structures of the classes used being known, the operations requesting a class resolution are replaced by the corresponding operations without class resolution.

The graphs illustrated in Figures 1 and 2 define the steps leading to the creation of the final binary respectively with and without the use of the method of the invention.

The classes thus defined are initialized when the Java system starts. They are grouped by package. Each of the packages provides a list of its classes as well as all of the packages with classes used by one of the entities in the package. This grouping into packages provides, during the exploitation of the invention, the opportunity to make simplifications relating to the class affinities of the same package, in particular on the visibility of the properties. This grouping also has the advantage of reducing processing during the implementation of the method of the invention.

The method of the invention therefore makes it possible to prepare the Java classes for almost immediate use at system startup.

The invention also relates to the tool for generating native structures from Java binaries, which thus makes it possible to prepare Java classes. Compilation of Java sources / creation of class files.

Compilation is the process of transforming source code describing computer software into a set of elementary operations directly understood, that is to say interpreted, by the machine on which this program will be executed. In the case of the Java language, the basic unit of source code is the Java class. The result of the compilation is a set of files, each file describing a class, as well as its methods. The Java virtual machine is the environment in which the programs thus compiled take place.

The tool of the invention exploits these class structures so as to prepare them for immediate integration into the class database of the class manager.

Integration of class files into binary Class files are included in the binary of the virtual machine as data structures directly understood by the class manager. These data structures are described by source code in C language.

Class preparation tool

The source code is built by a tool capable of understanding class files and familiar with the data structures of the class manager.

This tool works on files classes, as described by the Java language specifications, interpret their content, and provide data structures compatible with those of the class manager of the virtual machine.

Example of implementation

The implementation of the invention is closely linked to the internal definition of the class structures and associated entities.

We will therefore successively consider the structures used (class database), a way of solving the constraints linked to the invention, and finally an example of result produced on application of the invention

Class database

The class manager maintains a database of loaded classes. The structures, entities relevant in the context of the invention, are described below; these are class structures, properties, as well as link tables associated with each of the classes.

Structure describing a class

Various information is associated with each of the classes, among others:

• A reference to the super-class.

• The list of methods of the class (a list of references to structures describing the methods). • The list of references to structures describing the attributes defined by the class.

• A table of unresolved references to classes, methods or attributes necessary for the proper functioning of the methods of the class.

Structure describing an attribute Each attribute of a class is described by a structure providing, among other things, the following information:

• The name and signature of the attribute.

• A reference to the value of the attribute.

• The visibility of the attribute.

Structure describing a method

The methods of a class are described by a structure defining, among other things, the following information, for each of the methods:

• The name and signature of the method. • The visibility of the method.

• The method code.

Reference table table / constants The reference table is defined by the number of elements, as well as by each of its elements.

More generally, it is the table of class constants.

Each of the elements of the table is defined by the following set of information: • An element resolution indicator, indicating if its access requires a prior resolution.

• The type of the element. • The reference to the (definition of) constant.

Resolving an entry in the constant table amounts to finding the value of the constant and substituting the reference to the definition of the constant by the constant itself.

A summary diagram of the structures associated with Java classes is illustrated in Figure 3.

Resolution of the constraints associated with the method of the invention

The constraints mentioned above are reviewed and the associated technical solutions are described below.

The entities used must be known The entities used by a class

(other classes, properties, ...) must be resolved so as to be able to keep the table of constants for a class in ROM memory. These entities are found in the table of constants.

The table constants are initially unresolved. Each of the constants is associated with the information necessary to solve it (for a class constant, the name of the class is for example specified). The resolution of a constant is done only once during the lifetime of the class.

The application of the method of the invention for a class involves solving the entries in the table of constants.

Regarding class type constants, solving the class ultimately means applying the method of the invention to the class.

Java code must be based on resolved entities

Some Java bytecodes are operations using an argument whose value is in the table of constants. For performance reasons, bytecodes requiring constant resolution are associated with an equivalent bytecode achieving the same functionality, but assuming that the constant is already resolved, called "bytecode quick" below.

After successfully resolving a constant, the bytecode that requested the resolution of the constant is replaced by its quick bytecode.

The tool of the invention can therefore replace the bytecodes using constants to be resolved by quick bytecodes, since the entities used must be resolved.

Symbols associated with the source code generated • Breakdown into packages

The invention is applied to packages. The package is associated with the following information: an array of classes, a class being known by its index in the array.

Compilation constants are defined, these constants establish the link “index of a class in the table <-> class structure”.

The symbol name associated with the array is constructed from the name of the package.

• Reference on a class

The reference to a class of another package is done in the form: & Tableaupaquetage [INDEX_DE_LA_CLASSE], which is the address of the element INDEX_DE_LA_CLASSE in the table.

• Reference on the methods of a class

As with the classes in a package, the methods are grouped in an array. The method table is accessible from a symbol, whose name is associated with the name of the class.

• Reference on the attributes of a class

The attributes of a class are also grouped into a list. This list is presented in the form of a table. The symbol name associated with the array is a function of the class name. Example of result produced on application of the method of the invention

Description of Java classes

The Java class architecture used for the example is as follows:

The classes belong to the test.brevet package. To give a concrete but simple example, two classes are used: Classel and

Classe2, as well as an Interfacel interface, such as:

• Classel implements the Interfacel interface and inherits from the Java class. lang.Object, class from which all other classes in the system inherit. • Classe2 inherits from Classel.

• Interfacel describes a methodel method which is defined in the classes (Classel and Classe2) implementing this interface.

• Classel defines two methods: the String toStringO method overrides that of the class

Java. lang.Object; the methodel () method displays a small message on the text output of the virtual machine.

• Classe2 defines two methods: the methodel () method overloads that of Classel and displays another small message; the method method2 displays yet another message on the text output.

The definitions of the classes and interfaces are as follows: Interfacel source file. Java test package. Patent; public interface Interfacel {public void method (); }

Classel source file. Java

test package, patent; public class Classel extends java. lang. Object implements Interfacel {public String toString () {return "Classel"

} public void methodel () {System. out .println ("a little message")

>}

Classe2.java source file

test package, patent public class Class2 extends Classel {public void methodel () {

System. out .println ("another little message"); }

}

Product structures

The result of the application of the method of the invention is defined below: here, it is the transformation of Java sources previously defined, after their compilation, in source code in the C language describing the corresponding structures of the class database of the virtual machine.

External definitions

#include <MhwTypes.h>

#include <MhwMemory.h>

#include <MhwObject .h> #include <MhwClassF.h>

#include <MhwInterpreterF .h>

#include <MhwClassRom.h>

#include <java / lang / stubs / java_lang_String.h>

#include <test / patent / stubs / ClassRom.h> #include <java / lang / stubs / ClassRom.h>

#include <test / patent / stubs / ClassRom.h>

Static const char cString_0 [] "<init>"; static const char cString_l [] "OV"; static const char cString_2 [] "methodel"; static const char cString_3 [] "toString"; static const char cString_4 [] "() Ljava / lang / String; static const char cString_7 []" test / patent / Classel "; static const char cString_8 []" Classel. java "; static const char cString_10 [] -" test / patent / Class2 "; static const char cString_ll [] -" Class2. java "; static const char cString_12 []" test / patent / Interfacel "; static const char cString_13 [] ^: " Interfacel. java ";#ifndef CLASSROM_OPTIMIZE static const char cString_5 []" this "; static const char cString_6 []" Ltest / patent / Classel; "; static const char cString_9 []" Ltest / patent / Class2; ";#endif / * CLASSROM _^ OPTIMIZE * /

Classel class bytecode

static CLASSROM_CONST Card8 byteCode_0 [] = {

/ * 0 * / 0x2A, OxDC, 0x00, 0x08, OxBl}; #ifndef CLASSROM_OPTIMIZE static const MhwClmLineno Lineno_0 [] = {

{/ * 0 * / 0, 32} ^} ; #endif / * CLASSROM_OPTIMIZE * /

#ifndef CLASSROM_OPTIMIZE static const MhwClmLocalVar LocalVar_0 [] =

{

{/ * 0 * / 0, 5, 5, 6, 0}

};

#endif / * CLASSROM_OPTIMIZE * /

static CLASSROM_CONST Card8 byteCode_l [] =

{

/ * 0 * / 0xD2, 0x00, 0x02, OxCB, 0x03, 0xD6, OxlD, 0x02, OxBl

}; tifndef CLASSROM_OPTIMIZE static const MhwClmLineno Lineno_l [] =

{

{/ * 0 * / 0,

37

^} ,

{/ * 1 * / 8.36

}}; #endif / * CLASSROM_OPTIMIZE * /

#ifndef CLASSROM_OPTIMIZE static const MhwClmLocalVar LocalVar_l [] {

{/ * 0 * / 0, 9, 5, 6, 0}}; #endif / * CLASSROM_OPTIMIZE * /

static CLASSROM_CONST Cardδ byteCode_2 [] {/ * 0 * / OxCB, 0x01, OxBO};

#ifndef C ASSROM_OPTIMIZE static const MhwClmLineno Lineno_2 [] = {

{/ * 0 * / 0.34

}};

#endif / * CLASSROM OPTIMIZE * /

tifndef CLASSROM__OPTIMIZE _, static const MhwClmLocalVar LocalVar_2 [] {

{/ * 0 * / 0, 3, 5,

6, 0

}}; #endif / * CLASSROM OPTIMIZE * / Data from the table of constants / references of the class Classel static const Cardlβ character_0 [] = {

/ * 0 * / 0x0043, 0x006C, 0x0061, 0x0073, 0x0073, 0x0065, 0x0031}; static const HArrayOfChar arrayOfChar__0 =

{

(const ArrayOfChar) character_0, (void *) (0x7055)

>; static const Classjava_lang_String stringStruct_0 = {

(struct HArrayOfChar *) & arrayOfChar_0, 0, 7}; static const Hjava_lang_String string__0 = {(Classjava_lang_String *) & stringStruct_0, (void *) (&java_lang_String__MethodTable)}; static const Cardlβ character_l [] = {

/ * 0 * / 0x0075, OxOOβE, 0x0020, 0x0070, 0x0065, 0x0074, 0x0069, 0x0074, 0x0020, 0x006D,

/ * 10 * / 0x0065, 0x0073, 0x0073, 0x0061, 0x0067, 0x0065}; static const HArrayOfChar arrayOfChar__l = {

(const ArrayOfChar) character_l, (void *) (0x10055)}; static const Classjava_lang_String stringStruct_l = {(struct HArrayOfChar *) & arrayOfChar_l, 0, 16 }; static const Hj ava_lang_String string_l = {(Classj ava_lang_String *) & stringStruct_l,

(void *) (&java_lang_String_MethodTable)}; static const Hj ava_lang_Class test_brevet_Classel__Handle = {

(Classj ava_lang_Class *) & (test_brevet_Class_Entry [TEST_B REVET_CLASSE1]), (void *) & java_lang_Class_MethodTable

};

Classel Class Method Table static const struct {const MhwClmClass * classdescriptor; const MhwClmMethod * methods [13]; } test_brevet_Classel_MethodTable = {

(const MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLAS SE1]), {

NULL,

(MhwClmMethod *) & (java_lang_Object_Method [2]) / * 1 * /,

(MhwClmMethod *) & (test_brevet_Classel_Method [2]) / * 2 * /,

(MhwClmMethod *) & (java_lang_Object_Method [11]) / * 3

* /

(MhwClmMethod *) & (java_lang_Object_Method [9]) / * 4 * /, (MhwClmMethod *) & (java_lang_0b ect_Method [3]) / * 5

* /

(MhwClmMethod *) & (java_lang_0bject_Method [10]) / * 6

* /

(MhwClmMethod *) & (java_lang_Object_Method [4]) / * 7 * /,

(MhwClmMethod *) & (java_lang_Obj ect_Method [5]) / * 8 * /, (MhwClmMethod *) & (java_lang_Obj ect_Method [6]) / * 9

* /

(MhwClmMethod *) & (java_lang_0bject_Method [7]) / * 10

* /, (MhwClmMethod *) & (j ava_lang_Obj ect_Method [1]) / * 11

* /

(MhwClmMethod *) & (test_brevet_Classel_Method [l]) / * 12 * />}; static const Cardlβ interfaceslmplemented_0 [] =

{

/ * 0 * / 0x0004};

Class 2 bytecode static CLASSROM_CONST Card8 byteCode_3 []

{

/ * 0 * / 0x2A, 0xD7, 0x00, 0x03, OxBl

}; tifndef CLASSROM_OPTIMIZE static const MhwClmLineno Lineno_3 [] =

{

{/ * 0 * / 0, 32}}; #endif / * CLASSR0M_0PTIMIZE * /

#ifndef CLASSROM_OPTIMIZE static const MhwClmLocalVar LocalVar_3 []

{

{/ * 0 * / 0, 5, 4, 5, 0}

};

#endif / * CLASSROM_OPTIMIZE * / static CLASSROM_CONST Card8 byteCode_4 [] = {/ * 0 * / 0xD2, 0x00, 0x01, OxCB, 0x02, 0xD6, OxlD, 0x02, OxBl};

#ifndef CLASSROMJDPTIMIZE static const MhwClmLineno Lineno_4 [] = {

{/ * 0 * / 0.34},

{/ * 1 * / 8, 33

}}; tense / * CLASSROM_OPTIMIZE * /

#ifndef CLASSROM_OPTIMIZE static const MhwClmLocalVar LocalVar_4 [] {

{/ * 0 * / 0, 9, 4, 5, 0}}; #endif / * CLASSROM_OPTIMIZE * /

Data from the constants / references table of class Classe2 static const Cardlβ character_2 [] = {

/ * 0 * / 0x0075, OxOOβE, 0x0020, 0x0061, 0x0075, 0x0074, 0x0072, 0x0065, 0x0020, 0x0070, / * 10 * / 0x0065, 0x0074, 0x0069, 0x0074, 0x0020, OxOOβD, 0x0065, 0x0073, 0x0073, 0x0061,

/ * 20 * / 0x0067, 0x0065 }; static const HArrayOfChar arrayOfChar_2 =

{(const ArrayOfChar) character_2, (void *) (0x16055)}; static const Classjava_lang_String stringStruct_2 = {

(struct HArrayOfChar *) & arrayOfChar_2,

0

22

}; static const Hjava_lang_String string_2 =

{

(Classjava_lang_String *) & stringStruct_2, (void *) (&java_lang_String_MethodTable)}; static const H ava_lang_Class test_brevet_Classe2_Handle = {

(Classjava_lang_Class *) & (test_brevet_Class_Entry [TEST_B REVET_CLASSE2]),

(void *) &java_lang_Class_MethodTable};

Class2 class method table static const struct {const MhwClmClass * classdescriptor; const MhwClmMethod * methods [13]; } test_brevet_Classe2_MethodTable =

{(const

MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLAS SE2]),

{ULL, (MhwClmMethod *) & (java_lang_Object_Method [2]) / * 1 * /, (MhwClmMethod * & (test_brevet_Classel_Method [2]) / *

2 * /,

(MhwClmMethod * & (java_lang_Objectjy [ethod [ll]) / * 3

* /, (MhwClmMethod * & (java_lang_0bject_Method [9]) / * 4

* /, (MhwClmMethod * & (j ava__lang_Obj ectjylethod [3]) / * 5

* /, (MhwClmMethod * & (java_lang_Object_Method [10]) / * 6

* /, (MhwClmMethod * & (java_lang_Obj ect_Method [4]) / * 7

* /, (MhwClmMethod * & (java_lang_Object_Method [5]) / * 8

* /, (MhwClmMethod * & (java_lang_Obj ect ylethod [6]) / * 9

* /, (MhwClmMethod * & (java_lang_Object_Method [7]) / * 10

* /, (MhwClmMethod * & (java_lang_Object_Method [1]) / * 11

* /

(MhwClmMethod * & (test_brevet_Classe2_Method [l]) / * 12 * /

}}; static const Hjava_lang__Class test_brevet_Interfacel_Handle = {

(Classjava_lang_Class *) & (test_brevet_Class__Entry [TEST_B REVET_INTERFACE1]),

(void *) & j ava_lang_Class_MethodTable};

Interfacel static const struct interface methods table

{const MhwClmClass * classdescriptor; const MhwClmMethod * methods [13]; } test_brevet_Interfacel_MethodTable =

{

(const MhwClmClass * ⁾ & ⁽ test_brevet_Class_Entry [TEST_BREVET_INTE RFACEl]),

{ NULL

(MhwClmMethod * & (java_lang_0bject_Method [2]) / * 1 * /,

(MhwClmMethod * & (java_lang_Object_Method [8]) / * 2 * /,

(MhwClmMethod * & (j ava_lang_Obj ect_Method [11]) / * 3

* /

(MhwClmMethod * & (java_lang_Obj ect_Method [9]) / * 4

* /, (MhwClmMethod * & (java_lang_Object_Method [3]) / * 5 * /,

(MhwClmMethod * & (java_lang_Object_Method [10]) / * 6

* /

(MhwClmMethod * & (java_lang_Object_Method [4]) / * 7 * /,

(MhwClmMethod * & (java_lang_Object_Method [5]) / * 8 * /,

(MhwClmMethod * & (java_lang_Obj ect_Method [6]) / * 9

* /, (MhwClmMethod * & (java_lang_Object_Method [7]) / * 10

* /

(MhwClmMethod * & (java_lang_Object_Method [l]) / * 11

* /

(MhwClmMethod * & (test_brevet_Interfacel_Method [0]) / * 12 * /} ^} ;

Definition of methods of the Classel const class MHW_CLM_METHOD_STRUCT_TYPE test_brevet_Classel_Method [] =

{

{/ * 0 * /

{

(MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLA SSE1]), / * class * / (char *) cString_0, / * name: <init> * / (char *) cString_l, / * type: () V * / 0 | ACC_PUBLIC, 3409, / * hashcode * / 0 / * offset * /},

5, / * code length * / (Card8 *) byteCode_0, MhwIntlnvokeJavaMethod, NULL, / * catch table * /

0, / * catch count * /

1, / * arg size * / 1, / * max stack * /

1 / * nlocals * /

, CLASSROM_LINENO_TABLE (Lineno_0),

CLASSROM_LINENO_COUNT (1),

CLASSROM_LOCALVAR_COUNT (1), CLASSROM_LOCALVAR_TABLE (LocalVar_0),

NULL / * thrown exceptions * /}, {/ * 1 * /

{

(MhwClmClass *) & (test_brevet_Class__Entry [TEST_BREVET_CLA SSE1]), / * class * /

(char *) cString_2, / * na e: methodel * / (char *) cString_l, / * type: () V * / 0 | ACC_PUBLIC,

4247, / * hashcode * / 12 / * offset * /

^} ,

9, / * code length * / (Card8 *) byteCode_l,

MhwIntlnvokeJavaMethod, NULL, / * catch table * /

0, / * catch count * /

1, / * arg size * / 2, / * max stack * /

1 / * nlocals * /

, CLASSROM_LINENO_TABLE (Lineno_l),

CLASSROM_LINENO_COUNT (2),

CLASSROM_LOCALVAR_COUNT (l), CLASSROM_LOCALVAR_TABLE (LocalVar_l),

NULL / * thrown exceptions * /

}

{/ * 2 * /

{

(MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLA

SSE1]), / * class * /

(char *) cString_3, / * name: toString * / (char *) cString_4, / * type: () Ljava / lang / String;

0 | ACC_PUBLIC, 2189, / * hashcode 2 / * offset * /

}

3, / * code length * / (Cardδ *) byteCode_2, MhwIntlnvokeJavaMethod, NULL, / * catch table * /

0, / * catch count * /

1, / * arg size * / 1, / * max stack * / 1 / * nlocals * /

, CLASSROM_LINENO_TABLE (Lineno_2), CLASSROM_LINENO_COUNT (1), CLASSROM_LOCALVAR_COUNT (1), CLASSROM_LOCALVAR_TABLE (LocalVar_2) NULL / * thrown exceptions * /}};

Table of constants / references of the Classel class static const void * test_brevet_Classel__CP [] = {

(const void *) NULL, / * 1 * / (const void *) & string_0,

/ * 2 * / (const void *) & (java_lang_System_Field [2]), / * 3 * / (const void *) & string_l, / * 4 * / (const void *) & (test_brevet_Class_Entry [TEST_BREVET_INTERFACE1])

#ifndef CLASSROM_OPTIMIZE

/ * 5 * / (const void *) cString_5 / * C String * /, / * 6 * / (const void *) cString_6 / * C String * / #endif / * CLASSROM_OPTIMIZE * /

};

Definition of methods of class Classe2 const MHW_CLM_METHOD_STRUCT_TYPE test_brevet_Classe2_Method [] = {

{/ * 0 * / { (MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLA SSE2]), / * class * /

(char *) cString_0, / * name: <init> * / (char *) cString_l, / * type: () V * / 0 | CC_PUBLIC, 3409, / * hashcode * / 0 / * offset * /

^} , 5, / * code length * / (Card8 *) byteCode_3, MhwIntlnvokeJavaMethod, NULL, / * catch table * /

0, / * catch count * / 1, / * arg size * /

1, / * max stack * / 1 / * nlocals * /

, CLASSROM_LINENO_TABLE (Lineno_3), CLASSROM_LINENO_COUNT (1), CLASSROM_LOCALVAR_COUNT (1),

CLASSROM_LOCALVAR_TABLE (LocalVar_3),

NULL / * thrown exceptions * /},

{/ * 1 * / {

(MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLA SSE2]), / * class * /

(char *) cString_2, / * name: methodel * / (char *) cString_l, / * type: () V * /

0 | ACC_PUBLIC,

4247, / * hashcode * /

12 / * offset * /

^} , 9, / * code length * /

(Card8 *) byteCode_4, MhwIntlnvokeJavaMethod, NULL, / * catch table * / 0, / * catch count * / 1, / * arg size * /

2, / * max stack * / 1 / * nlocals * /

, CLASSROM_LINENO_TABLE (Lineno_4), CLASSROM_LINENO_COUNT (2), CLASSROM_LOCALVAR_COUN (1),

CLASSROM_LOCALVAR_TABLE (LocalVar_4), NULL / * thrown exceptions * / };

Class 2 constants / references table static const void * test_brevet_Classe2_CP [] = {

(const void *) NULL, / * 1 * / (const void *) & (java_lang__System_Field [2]),

/ * 2 * / (const void *) & string_2,

/ * 3 * / (const void *) & (test_brevet__Classel_Method [0]) #ifndef CLASSROM OPTIMIZE

/ * 4 * / (const void *) cString_5 / * C String * /, / * 5 * / (const void *) cString_9 / * C String * /

#endif / * CLASSROM_OPTIMIZE * /

};

Definition of the methods of the Interfacel const MH interface _CLM_METHOD_STRUCT_TYPE test_brevet_Interfacel_Method [] =

{

{/ * 0 * / {(MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET__INT ERFACE1]), / * class * /

(char *) cString_2, / * name: methodel * /

(char *) cString_l, / * type: () V * /

0 | ACC_PUBLIC | ACC_ABSTRACT, 4247, / * hashcode * /

12 / * offset * /

}

0, / * code length * / NULL, / * byte code * / MhwIntlnvokeAbstractMethod, NULL, / * catch table * /

0, / * catch count * /

1, / * arg size * / 0, / * max stack * / 0 / * nlocals * /

, NULL, / * lineno table * / 0, / * lineno count * / 0, / * localvar count * / NULL, / * localvar table * / NULL / * thrown exceptions * /}

Defining the classes of the const package MhwClmClassRom test_brevet_Class_Entry [] =

{

{/ * 0 * /

(char *) cString_7, / * name: test / patent / Classel * / (MhwClmClass *) & (j ava_lang_Class_Entry [JAVA_LANG_OBJECT]), / * superclass * /

92, / * hashcode * /

CLASSROM_ACCESS (CLASS_ROM | CLASS_PUBLIC),

0, / * object size * / NULL, / * outerclass * /

NULL, / * adrStaticFields * /

0, / * sizeStaticFields * / NULL, / * fields * / CLASSROM_FIELD_COUN (0,0,0), 3, / * method count * /

(MhwClmMethod *) test_brevet_Classel_JMethod, (MhwClmConstantPool *) test__brevet_Classel_CP,

NULL, / * class loader * /

NULL, / * clinit * / NULL, / * finalizer * /

(Hjava_lang_Class *) & test_brevet_Classel_Handle, / * class handle * /

(MhwClmMethodTable *) & test_brevet_Classel_MethodTable, 13, / * ethodtable size * /

1, / * interface count * / (Cardl6 *) interfaceslmplemented_0,

(char *) cString_8, / * source name: Classel. java * /

NULL, / * protection domain * /

VOID, / * super class name * /

VOID, / * strings * /

(Cardlβ) 3, / * major_version * /

(Cardlβ) 3, / * minor_version * /

(Cardlβ) 7, / * cp_count * /

(Card8): 29 / * status * /

} {'/ * i * / (char *) cString_10, / * name: test / patent / Class2 * /

(MhwClmClass *) & (test_brevet_Class_Entry [TEST_BREVET_CLA SSEl]), / * superclass * / 93, / * hashcode * /

CLASSROM_ACCESS (CLASS_ROM | CLASS_PUBLIC),

0, / * object size * /

NULL, / * outerclass * /

NULL, / * adrStaticFields * / 0, / * sizeStaticFields * /

NULL, / * fields * /

CLASSROM_FIELD_COUNT (0,0,0),

2, / * method count * /

(MhwClmMethod *) test_brevet_Classe2__Method, (MhwClmConstantPool *) test_brevet_Classe2_CP,

NULL, / * class loader * /

NULL, / * clinit * /

NULL, / * finalizer * /

(Hjava_lang_Class *) & test_brevet_Classe2_Handle, / * class handle * /

(MhwClmMethodTable *) & test_brevet_Classe2_MethodTable, 13, / * methodtable size * / 0, / * interface count * / NULL, / * interfaces implemented * /

(char *) cString_ll, / * source name: Classe2.java * /

NULL, / * protection domain * /

NULL, / * super class name * /

NULL, / * strings * /

(Cardlβ) 3, / * major_version * /

(Cardlβ) 3, / * minor_version * /

(Cardlβ) 6, / * cp_count * /

(Cardδ) 29 / * status * /

} {/ * 2 * / ^'

(char *) cString_12, / * name: tteest / patent / Interfacel

7

(MhwClmClass *) & (j ava_lang_Class_Entry [JAVA_LANG_OBJECT]), / * superclass * /

394, / * hashcode * /

CLASSROM_ACCESS (CLASS_ROM | CLASS_PUBLIC | CLASS_INTERFACE | CLASS_ABSTRACT), 0, / * object size * /

NULL, / * outerclass * /

NULL, / * adrStaticFields * / 0, / * sizeStaticFields * / NULL, / * fields * / CLASSROM_FIELD_COUNT (0,0,0),

1, / * method count * / (MhwClmMethod *) test_brevet_Interf cel_Method, NULL, / * constant pool * / NULL, / * class loader * / NULL, / * clinit * / NULL, / * finalizer * / (Hjava_lang_Class *) & test_brevet_Interfacel_Handle , / * class handle * /

(MhwClmMethodTable *) & test_brevet_Interfacel_MethodTable 13, / * methodtable size * / 0, / * interface count * / NULL, / * interfaces implemented * /

(char *) cString_13, / * source name: Interfacel. java * / NULL, / * protection domain * / NULL, / * super class name * / NULL, / * strings * / (Cardlβ) 3, / * ma or_version * / (Cardlβ) 3, / * minor_version * / (Cardlβ ) 1, / * cp_count * / (Card8) 29 / * status * /

Miscellaneous information const Card32 test_brevet_ClassNumber = 3; const Card32 test_brevet_CheckSum = 773706915; const Card32 test_brevet_PackageUsedNumber = 2; const PackageUsedStruct test_brevet_PackageUsedArray []

{

{

JAVA_LANG_CHECKSUM_VALUE, & j ava_lang_CheckSum, "java / lang"

^} ,

{ TEST_BREVET_CHECKSUM_VALUE, & test_brevet_CheckSum, "test / patent"

Claims

1. Class management method for an object oriented language based on a dynamic resolution of object classes, characterized in that the resolution of at least one dynamic class is transformed, for a group of autonomous classes, into static resolution.

2. Method according to claim 1, used in a Java virtual machine for a set of autonomous classes, in which the native structure exploited directly by the Java kernel of these classes is included as binary data of the virtual machine.

3. Method according to claim 2 used in an embedded system, in which the native structure of these classes is included as binary data of the virtual machine in a form implying an optimization of the memory resources of the system as well as an optimization in speed of execution of bytecode of class methods.

4. Method according to claim 3, in which source files are created in native language describing the native structures corresponding to the autonomous set of classes.

5. Method according to claim 4, in which the autonomous set of classes is cut into subsets corresponding to Java packages, these subsets are not individually autonomous and rules for naming symbols are established so as to be able to reference a class of a package from a class of another package.

6. The method of claim 5, wherein in the context of the description of methods and more particularly in the context of the description of the bytecode of methods, on. replaces the bytecode requiring the resolution of an entity by the bytecode performing the same functionality but which assumes that the entity is resolved.

7. Tool for generating native structures from the object binaries, implementing the method according to any one of the preceding claims.