Dynamic Binding

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.

Talking about ids: Routine_id, body_id, real_body_id and type_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.

Every routine body, that means every declaration or redeclaration, gets its own unique body_id.

In the following picture it is shown how these ids could look like:

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. The code snipped how the dynamic binding works:

void Fcubdx0 (EIF_REFERENCE Current, EIF_REFERENCE arg1) { ... (FUNCTION_CAST(void, (EIF_REFERENCE)) Txioci5[Dtype(arg1)-50])(arg1); ... }

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.