Dynamic Binding

Revision as of 02:48, 11 January 2007 by Konradm (Talk | contribs) (Dynamic binding in finalized code)

Warning.png Warning: Warning: Article under development

Introduction

Dynamic binding is a key feature behind object technology. In the following piece of code:

foo (a: A)
   do
      a.f
   end

It is not known at compile time, which feature has to be called for call a.f. This depends on the exact type of the object referenced by a, also called its dynamic type.

Some Ids

In the following sections several ids are introduced. Their explanation is based on the following example system (Further referenced as the ABC system):

DynamicBindingABCExample.jpg

routine_id

In a compiled Eiffel system, every feature that is a seed gets its own unique routine_id. Features that are just inherited or are a redeclaration have the same routine_id as their precursor (See Routine IDs).

It is possible for a feature to have more than one routine_id when it has more than one precursor. This is the case for feature j of class C that redefines both feature g of A and feature h of B and thus gets both their routine_id's.

As it will be shown later, the chosen routine_id have an impact on the dynamic binding semantics. In class C the feature f_b gets the routine_id 1 since it is selected, the not selected feature f of C gets a new routine_id.

body_id and real_body_id

Every routine body, that means every declaration or redeclaration, gets its own unique body_id. The body_id of feature g in classes A and B are the same since g is not redefined in B.

A body of a generic class may need several translated versions, when there are different type instantiations of the class. For getting the right version of the correct type instantiation the real_body_id is used. There might be for example two translations for feature f of class A. One for each of the types A [INTEGER] and A [STRING]. Their real_body_id will thus be different.

feature_id

Every feature of a class gets a feature_id that is unique in the context of this class.

class_id and type_id

Every class gets a unique class_id an every type a unique type_id.

Dynamic binding in finalized code

In finalized code the dynamic binding is very simple. For every routine_id there exists an array, that maps dynamic type ids to function pointers. This array is called routine table.


The code snipped shows how the routine table for routine_id 1 looks like and on the right side a dynamically bound call:

char *(*Txiockf[6])();
void Txiockf_init () {
   Txiockf[0] = (char *(*)()) A_INTEGER_f;
   Txiockf[1] = (char *(*)()) A_REFERENCE_f;
   Txiockf[2] = (char *(*)()) B_INTEGER_f_g;
   Txiockf[3] = (char *(*)()) B_REFERENCE_f_g;
   Txiockf[4] = (char *(*)()) B_INTEGER_f_g;
   Txiockf[5] = (char *(*)()) B_REFERENCE_f_g;
}
void Fcubdx0 (EIF_REFERENCE Current, EIF_REFERENCE arg1) {
   ...
   (FUNCTION_CAST(void, (EIF_REFERENCE)) 
      Txiockf[Dtype(arg1)-50])(arg1);     //Offset 50 is used to allow
   ...                                    //a smaller routine table
}

The function names in the routine table are artificial to ease its understanding.

Two facts become obvious:

  • The type_id of inherited classes should be close together, otherwise the routine tables will have big holes and become huge.
  • When in the above example an object of a wrong type is passed to Current it will have disastrous consequences.


In this example the type_id for A body_id refers to a certain body of a class. The real_body_id refers a body of one specific generic derivation of a class. The real_body_id is very important in workbench mode. Once the real_body_id is resolved for a call, the rest is just melting ice stuff. In the call to a.f the routine_id of f is known.