Index: /reasoner/consTranslation.tex =================================================================== --- /reasoner/consTranslation.tex (revision 216) +++ /reasoner/consTranslation.tex (revision 217) @@ -501,7 +501,7 @@ \subsubsection{Translating Annotation Assignment Blocks}\label{sectAnnAssngBlocks} -We turn now to the second pattern, the translation of annotation assignments. The idea of Algorithm \ref{algTranslateAnnotationAssignments} is to incrementally create the set of effective assignments for the actual annotation assignment in order to ensure that only the innermost assignment data is applied. More technically, we build a mapping based on the names of the annotations and override inherited assignments with by those specified by the annotation assignment to be processed. - -Algorithm \ref{algTranslateAnnotationAssignments} receives the annotation assignment $a$ to process, the optional parent variable $v$ containing $a$, the mapping of effective assignment data objects $ea$ and an optional access expression $ca$ to $v$. Initially, Algorithm \ref{algTranslateAnnotationAssignments} is called with an empty mapping $ea=\emptyMap$. In line \ref{algTranslateAnnotationAssignmentsUpdateEA}, Algorithm \ref{algTranslateAnnotationAssignments} updates $ea$ by adding all assignment data objects defined by the actual annotation assignment $a$. +We turn now to Pattern \ref{fAnnotAssngBlock}, the translation of annotation assignment blocks. The idea of the translation Algorithm \ref{algTranslateAnnotationAssignments} is to incrementally create the set of effective assignments, starting from the outermost assignment block following the nesting of assignment blocks. The effective assignments ensure that only the innermost assignment data is applied, i.e., accidental re-assignments are avoided. Then, for each declared variable and each effective assignment, we create an assignment constraint before recursively applying the algorithm to assignment blocks nested within the current block. More technically, we build a mapping based on the names of the annotations and override assignments originating from containing assignment blocks by those specified by the actual annotation assignment block being processed. Thus, we keep the assignments from the innermost containing block that are not overridden and still must be considered for creating assignment constraints. + +Algorithm \ref{algTranslateAnnotationAssignments} receives the annotation assignment block $a$ to process, the optional parent variable $v$ containing $a$, the effective assignment data objects $ea$ and an optional access expression $ca$ to $v$. As introduced in Section \ref{sectNotationProject}, an assignment data object consists of the name of an assignment variable and an associated default value expression. Initially, Algorithm \ref{algTranslateAnnotationAssignments} is called with an empty mapping $ea=\emptyMap$. \begin{algorithm}[H] @@ -513,5 +513,6 @@ \ForAll{$d \iterAssng decls(a)$} {\label{algTranslateAnnotationAssignmentsLoopStart} $a_d\assng ea[name(d)]$\; \label{algTranslateAnnotationAssignmentsObtainEA} - $add(\otherConstraints, \set{translateAnnotationAssignment(a_d, d, ca, \variableMapping)}, false, \undef)$\; \label{algTranslateAnnotationAssignmentsTranslateBasic} + $x\assng translateAnnotationAssignment(a_d, d, ca, \variableMapping)$\; + $add(\otherConstraints, \set{x}, false, \undef)$\; \label{algTranslateAnnotationAssignmentsTranslateBasic} $t \assng type(d)$\; \If{$isCompound(t)$} {\label{algTranslateAnnotationAssignmentsIsCompoundStart} @@ -542,5 +543,5 @@ \end{algorithm} -For a given annotation assignment $a$, the algorithm processes all declared variables (lines \ref{algTranslateAnnotationAssignmentsLoopStart}-\ref{algTranslateAnnotationAssignmentsLoopEnd}). For each variable, the algorithm obtains the effective assignment data $a_d$ in line \ref{algTranslateAnnotationAssignmentsObtainEA}, creates the default value assignment constraint and adds it to $\otherConstraints$ in line \ref{algTranslateAnnotationAssignmentsTranslateBasic}. If the declared variable is of compound type (lines \ref{algTranslateAnnotationAssignmentsIsCompoundStart}-\ref{algTranslateAnnotationAssignmentsIsCompoundEnd}), we also must consider the compound slots. Therefore, the algorithm determines in lines \ref{algTranslateAnnotationAssignmentsActTypeStart}-\ref{algTranslateAnnotationAssignmentsActTypeEnd} the actual type of the declared variable $d$, which may differ from the declared type for annotations of compound type due to type refinement. In line \ref{algTranslateAnnotationAssignmentsAccess}, the algorithm determines the access expression $ac$ to the declared compound variable $d$, which may either be $ca.d$ if $ca$ is given, $v.d$ if $v$ is given or, as fallback, just $d$. Now, the algorithm can iterate over all slots of the compound annotation (lines \ref{algTranslateAnnotationAssignmentsSlotsStart}-\ref{algTranslateAnnotationAssignmentsSlotsEnd}), create an access expression for each slot in line \ref{algTranslateAnnotationAssignmentsSlotAccess}, i.e., $ac.s$, create the assignment constraint in line \ref{algTranslateAnnotationAssignmentsSlotConstraint} and add the resulting constraint to $\otherConstraints$ in line \ref{algTranslateAnnotationAssignmentsSlotConstraintAdd}. Finally, the algorithm recursively processes the nested annotation assignments in lines \ref{algTranslateAnnotationAssignmentsNestedStart}-\ref{algTranslateAnnotationAssignmentsNestedEnd} by calling Algorithm \ref{algTranslateAnnotationAssignments} recursively. +In line \ref{algTranslateAnnotationAssignmentsUpdateEA}, Algorithm \ref{algTranslateAnnotationAssignments} updates the effective assignments $ea$ by adding all assignment data objects defined by the actual annotation assignment $a$. For a given annotation assignment block $a$, the algorithm processes all declared variables (lines \ref{algTranslateAnnotationAssignmentsLoopStart}-\ref{algTranslateAnnotationAssignmentsLoopEnd}). For each variable, the algorithm obtains the effective assignment data $a_d$ in line \ref{algTranslateAnnotationAssignmentsObtainEA}, creates the default value assignment constraint and adds it to $\otherConstraints$ in line \ref{algTranslateAnnotationAssignmentsTranslateBasic}. If the declared variable is of compound type (lines \ref{algTranslateAnnotationAssignmentsIsCompoundStart}-\ref{algTranslateAnnotationAssignmentsIsCompoundEnd}), we also must consider the compound slots. Therefore, the algorithm determines in lines \ref{algTranslateAnnotationAssignmentsActTypeStart}-\ref{algTranslateAnnotationAssignmentsActTypeEnd} the actual type of the declared variable $d$, which may differ from the declared type for annotations of compound type due to type refinement. In line \ref{algTranslateAnnotationAssignmentsAccess}, the algorithm determines the access expression $ac$ to the declared compound variable $d$, which may either be $ca.d$ if $ca$ is given, $v.d$ if $v$ is given or, as fallback, just $d$. Now, the algorithm can iterate over all slots of the compound annotation (lines \ref{algTranslateAnnotationAssignmentsSlotsStart}-\ref{algTranslateAnnotationAssignmentsSlotsEnd}), create an access expression for each slot in line \ref{algTranslateAnnotationAssignmentsSlotAccess}, i.e., $ac.s$, create the assignment constraint in line \ref{algTranslateAnnotationAssignmentsSlotConstraint} and add the resulting constraint to $\otherConstraints$ in line \ref{algTranslateAnnotationAssignmentsSlotConstraintAdd}. Finally, the algorithm recursively processes the nested annotation assignments in lines \ref{algTranslateAnnotationAssignmentsNestedStart}-\ref{algTranslateAnnotationAssignmentsNestedEnd} by calling Algorithm \ref{algTranslateAnnotationAssignments} recursively. In lines \ref{algTranslateAnnotationAssignmentsTranslateBasic} and \ref{algTranslateAnnotationAssignmentsSlotConstraint}, Algorithm \ref{algTranslateAnnotationAssignments} relies on the translation of an individual assignment data object. The translation of a single assignment from an assignment data object $a$ leads to the creation of an assignment constraint as shown below.