DynBindModel: Difference between revisions
| Line 282: | Line 282: | ||
b \in \alpha_m | b \in \alpha_m | ||
\ |\ | \ |\ | ||
\left( \delta_{ S_{m-1} } \left( b, b \right)^{-1} | \left( \delta_{ S_{m-1} } \left( b, b \right)^{-1} ; \beta_S \left( b, C_m \right) \right)^{-1}\right) \right) \ll \tau_{m} | ||
& | & | ||
\mbox{if } q = p = m \\ | \mbox{if } q = p = m \\ | ||
| Line 289: | Line 289: | ||
b \in \alpha_m | b \in \alpha_m | ||
\ |\ | \ |\ | ||
\beta_S \left( C_q, C_m \right) | \beta_S \left( C_q, C_m \right); | ||
\left( \delta_{ S_{m-1} } \left( C_q, b \right)^{-1} | \left( \delta_{ S_{m-1} } \left( C_q, b \right)^{-1} ; \beta_S \left( C_q, C_m \right) \right)^{-1} \ll \tau_{m} \right) | ||
& | & | ||
\mbox{otherwise } | \mbox{otherwise } | ||
\end{cases} | \end{cases} | ||
</math> | </math> | ||
Revision as of 16:24, 3 October 2006
Motivation:
Eiffels dynamic binding is somewhat more complex than that of other languages. Its structure is still very simple and can be described by giving the relation:
Relation γ contains both the static and dynamic binding part of the language. In the following feature:
f (a: ANY)
do
print (a.out)
end
The static binding part of call a.out can be decribed as:
Namely an evaluation of γ with a tuple containing the static type of the call and the name. The result of this is a function. This function will be evaluated at runtime and yield the right feature according to the dynamic type of a.
In the rest of this text, the we will show how to construct the relation γ based on any given eiffel system.
Some fundamentals
We introduce the operator as the "ancestor of" and as "descendant of" operator.
Without loss of generality we can say that any Eiffel system is a set of classes such that if . In practice class will allways be class ANY but this is not of importance here.
The function:
Yields the features declared in a given class.
Yields the renamings of the different parent parts by a class:
gives the renamings in class D for the inherited class B.
Gives the classes from which a given class inherits:
Gives the base classes of the of class A.
Gives all the selected feature names of an inherited class of a class.
Furthermore we give the following shortcuts:
- for
- for
- for
- for
An example
For the following System:
class B feature f do ... end end |
class C inherit B rename f as f1 redefine f1 end feature f1 do ... end end |
class D inherit C select f1 end B rename f as f2 redefine f2 end B rename f as f3 redefine f3 end feature f2 do ... end f3 do ... end end |
We get:
The naming function
In this section the naming function of a system is shown:
Its structure
We will give a recursive definition of . Meaning that we will give given that we already now
This is valid since:
An example
Before we proceed to the definition we show how looks like for the example from the previous section:
|
|
|
|
| |
|
|
Its definition
We introduce the shortcut to denote the system
As a helper function we also need these functions:
And finally the naming function:
Where
And:
The dynamic binding function
With the naming function defined it is surprisingly simple to give the dynamic binding function. To make it even easier we define the function:
With this function defined we can derive :
What remains is to define . As with the naming function we do it recursively. We define based on since the following holds: