org.vishia.java2C
Class Docu.G_Instantiation

java.lang.Object
  org.vishia.java2C.Docu.G_Instantiation

Enclosing class:

Docu

 class Docu.G_Instantiation
extends java.lang.Object

This chapter describes some cohesion of allocation, initializing (construction), finalizing, garbage collection.

Docu.G_Instantiation

Docu.G_Instantiation()

g1_kindOfInstances

void g1_kindOfInstances()

In Java there are two kinds of instances:

• Primitive types such as int, float. This instances are created embedded or in stack. Their content is copied always if there are taken in a method call.
• Instances based on Object. This instances are created in the heap always, they are referenced. It the content is taken in a method call, a reference will be copied.

In opposite, in C there are given four kinds of instances:

• Primitive type, same as in Java.
• Embedded types. Their are only some types like MemC, StringJC or OS_TimeStamp, which are presented in that kind. This instances are used embedded only. They are taken as arguments or as return-value of methods per value anytime. They are never referenced. It is similar like primitive types. The embedded types are short structures, only consisting of less memory words. They should pass through registers as return value.
• Structured instances not base on Object.
• Structured instances based on Object. Both kinds of structured instances can be allocated in the heap, may be embedded in another structure and may be created in static memory space. It can be used with a reference, or maybe with given instance. If they are used as arguments or return values from methods, they are referenced anyway.

Embedded types are types, which are deployed in C with a simple small struct, handled call and return per value. There are applications for that concept for special cases. * FieldData.modeAccess = '$'

g2_allocation

void g2_allocation()

g3_referencingWithMemC

void g3_referencingWithMemC()

In the CRuntimeJavalike context a struct MemC {int32 size_; MemAreaC* address;} is defined. It is placed in the header file fw_MemC.h, because it is not a own concept of CRuntimeJavalike, but an own concept of common C-programming. This struct MemC is an answer about the question: I have a void*-pointer to the memory, but which and how many bytes.... In generally a void*-pointer is a undefined thing. No type is given, no size is known. A void* is a well concept in the C-language with its closure to machine level, but not for user-level programming.

An instance described with MemC is undefined in type, but defined in size. It is a representation of raw memory. An allocation of memory with alloc_MemC(size) returns this struct with the found address and the associated size. It is one parameter for using. Otherwise the size is separated from the void*-pointer and mistakes are possible. The MemC comprises only 2 register values. Therefore most of C compilers return it in machine level in 2 register, not in a copied struct. It is efficient.

g5_ctor

void g5_ctor()

The four kinds of instances (see g1_kindOfInstances()) uses several kinds of constructors to initial them with given arguments:

• Primitive types doesn't need a constructor. Initial values are assigned immediately.
• Embedded types are initialized calling a INIT...(THIS, ...)-routine. The first argument is the instance itself, not referenced. The INIT...(THIS, ...) should be implemented as a macro anyway. Mostly it is a simple macro.
• A non-ObjectJc-based instance is initialized with a ctorM...(MemC mthis, ...)- constructor. The memory space for the instance is given in a MemC-structure, which contains the pointer and the length information about the memory space of the instance. The MemC-value may be a return value of a alloc_MemC(size)-call or it is build from a given embedded instance using a build_MemC(ref, length)-method. The ctorM-method should check whether the memory space is large enough. It should not be assumed, that the data are initialized with 0. The initializing should be done in the constructor.
• A ObjectJc-based instance is initialized with a ctorO...(ObjectJc* othis, ...)- constructor. The memory space for the instance is given with the ObjectJc-pointer. The ObjectJc-data should be initialized already, only the reflection information can't be set. The size of the instance is contained in the ObjectJc-objectIdentSize value. It can be seen as guaranteed, that the rest of values are initialized with 0 already. Either the alloc_ObjectJc(...) method has initialized all allocated memory bytes with 0, and it has initialized the ObjectJc-base data, or the init_ObjectJc(...)-method should be do that.
  
  The ObjectJc-pointer may be a return value of a alloc_ObjectJc(size)-call or it is build from a given embedded instance with referencing it. The ctorO-method should check whether the memory space is large enough.<
  
  The initializing of an embedded instance should be done before calling the method init_ObjectJc(ObjectJc* ythis, int sizeObj, int identObj). This routine sets the initial values of the ObjectJc-data and sets the rest of data to 0.

g10_enhancedRefs

void g10_enhancedRefs()

g11_garbageCollection

void g11_garbageCollection()

g12_blockHeap

void g12_blockHeap()

g16_finalizing

void g16_finalizing()

Java knows a method Object.finalize(), which is called from the system before the instance is removed from memory. It is invoked in cohesion with the garbage collector. The finalize()- method can be overridden in any instance. But this method should be used carefully. It is not deterministic when and whether at all this method is invoked because the garbage- collector has its own rules. If the instance isn't use anymore, it is possible that it isn't removed by the garbage collector, because there is enough memory and thereby no need of freeing memory. A programmer shouldn't use this method for normal clearing up actions for example to close files.

In the case of using the #g5_blockHeap() the finalize method is used especially to remove enhanced references. The references may refer other instances which were in use, although the instance itself isn't use and it is freed therefore. The referred instances contains backward references to the freed instance. If the enhanced references are not cleaned, that backward references are faulty.

Therefore the finalize-method is generated from the Java2C-translator to clean the enhanced references. In the finalize()-method the finalized-methods of embedded instances and of the super classes are called too. If a user-written finalize()-method is present in the Java-code, its content will be included firstly.

Only for instances which aren't base on Object (simple data) and which doesn't contain enhanced references no finalize method is generated. The property ClassData.bFinalizeNeed contains the information about. It is set calling ClassData.needFinalize() or ClassData.setBodyForFinalize(org.vishia.zbnf.ZbnfParseResultItem). It is able to quest calling ClassData.isFinalizeNeed().

The finalize()-method is generated with SecondPass.write_finalizeDefinition(org.vishia.zbnf.ZbnfParseResultItem, String, LocalIdents).

g7_embeddedTypes

void g7_embeddedTypes()

Embedded types are types, which are deployed in C with a simple small struct, handled call and return per value. There are applications for that concept for special cases. * FieldData.modeAccess = '$'