AFortran2RSL-CallExpr.atl APascal2RSL-CallExpr.atl
1-- @atlcompiler atl2006 1-- @atlcompiler atl2006
2module AFortran2RSL; 2module APascal2RSL;
3create OUT : RSL from IN : AFortran; 3create OUT : RSL from IN : APascal;
4  4 
5helper context String 5helper context String
6    def: startsWith(s : String) : Boolean = 6    def: startsWith(s : String) : Boolean =
7        s.size() <= self.size() and self.substring(1, s.size()) = s; 7        s.size() <= self.size() and self.substring(1, s.size()) = s;
8  8 
9helper context String 9helper context String
10    def: endsWith(s : String) : Boolean = 10    def: endsWith(s : String) : Boolean =
11        let start : Integer = self.size() - s.size() + 1 in 11        let start : Integer = self.size() - s.size() + 1 in
12            start > 0 and self.substring(start, self.size()) = s; 12            start > 0 and self.substring(start, self.size()) = s;
13  13 
14  14 
15  15 
16rule AFortran2RSL { 16rule APascal2RSL {
17    from 17    from
18        s:  AFortran!AFortran 18        s:  APascal!APascal
19    to 19    to
20        t:  RSL!RSL ( 20        t:  RSL!RSL (
21            domain <-  s.domain, 21            domain <-  s.domain,
22            rslelems <-     Sequence { 22            rslelems <-     Sequence {
23                                  s.advice, 23                          s.advice,
24                                  thisModule.PointCutExprToMethodName(s.pointcut->first().pctexpr->first()), 24                          thisModule.PointCutExprToMethodName(s.pointcut->first().pctexpr->first()),
25                                  thisModule.PointCutExprToWithinCode(s.pointcut->first().pctexpr->last()), 25                          thisModule.PointCutExprToWithinCode(s.pointcut->first().pctexpr->last()),
26                                  s.pointcut->collect(e | thisModule.PointCutToExternalPattern(e)), 26                          s.pointcut->collect(e | thisModule.PointCutToExternalPattern(e)),
27                                  s.pointcut->collect(e | thisModule.PointCutToRule(e)) 27                          s.pointcut->collect(e | thisModule.PointCutToRule(e))
28                                 }, 28                         },
29            ruleset <- rs 29            ruleset <- rs
30        ), 30        ),
31        rs : RSL!RuleSet ( 31        rs : RSL!RuleSet (
32            rsname <- s.name, 32            rsname <- s.name,
33            rname <- s.pointcut->collect(e|e.name) 33            rname <- s.pointcut->collect(e|e.name)
34        ) 34        )
35} 35}
36  36 
37rule ApDomain2RSLDomain { 37rule ApDomain2RSLDomain {
38    from 38    from
39        s : AFortran!Domain 39        s : APascal!Domain
40    to 40    to
41        t : RSL!Domain ( 41        t : RSL!Domain (
42            dname <- s.name 42            dname <- s.name
43        ) 43        )
44} 44}
45  45 
46rule BeforeAdvice2Pattern { 46rule BeforeAdvice2Pattern {
47    from 47    from
48        s : AFortran!BeforeAdvice 48        s : APascal!BeforeAdvice
49    to 49    to
50        t : RSL!Pattern ( 50        t : RSL!Pattern (
51            phead <- ph, 51            phead <- ph,
52            ptoken <- 'execution_part_construct_list', 52            ptoken <- 'statement_list',
53            ptext <- spt 53            ptext <- spt
54        ), 54        ),
55        ph : RSL!PatternHead ( 55        ph : RSL!PatternHead (
56            name <- 'before_advice_stmt' 56            name <- 'before_advice_stmt'
57        ), 57        ),
58        spt : RSL!SimplePatternText ( 58        spt : RSL!SimplePatternText (
59            ptext <- s.advStmt->iterate(e; acc : String = '' | acc + if acc = '' then '' else '\r\n\t' endif + e.stmt) 59            ptext <- s.advStmt->iterate(e; acc : String = '' | acc + if acc = '' then '' else '\r\n\t' endif + e.stmt)
60        ) 60        )
61} 61}
62  62 
63rule GenerateAfterAdviceDummy extends BeforeAdvice2Pattern { 63rule GenerateAfterAdviceDummy extends BeforeAdvice2Pattern {
64    from 64    from
65        s : AFortran!BeforeAdvice ( 65        s : APascal!BeforeAdvice (
66            not s.aspect.advice->exists(e | e.oclIsKindOf(AFortran!AfterAdvice)) 66            not s.aspect.advice->exists(e | e.oclIsKindOf(APascal!AfterAdvice))
67        ) 67        )
68    to 68    to
69        t : RSL!Pattern, 69        t : RSL!Pattern,
70        at : RSL!Pattern ( 70        at : RSL!Pattern (
71            rsl <- s.aspect, 71            rsl <- s.aspect,
72            phead <- aph, 72            phead <- aph,
73            ptoken <- 'execution_part_construct_list', 73            ptoken <- 'statement_list',
74            ptext <- aspt 74            ptext <- aspt
75        ), 75        ),
76        aph : RSL!PatternHead ( 76        aph : RSL!PatternHead (
77            name <- 'after_advice_stmt' 77            name <- 'after_advice_stmt'
78        ), 78        ),
79        aspt : RSL!SimplePatternText ( 79        aspt : RSL!SimplePatternText (
80            ptext <- '' 80            ptext <- ''
81        ) 81        )
82} 82}
83  83 
84rule AfterAdvice2Pattern { 84rule AfterAdvice2Pattern {
85    from 85    from
86        s : AFortran!AfterAdvice 86        s : APascal!AfterAdvice
87    to 87    to
88        t : RSL!Pattern ( 88        t : RSL!Pattern (
89            phead <- ph, 89            phead <- ph,
90            ptoken <- 'execution_part_construct_list', 90            ptoken <- 'statement_list',
91            ptext <- spt 91            ptext <- spt
92        ), 92        ),
93        ph : RSL!PatternHead ( 93        ph : RSL!PatternHead (
94            name <- 'after_advice_stmt' 94            name <- 'after_advice_stmt'
95        ), 95        ),
96        spt : RSL!SimplePatternText ( 96        spt : RSL!SimplePatternText (
97            ptext <- s.advStmt->iterate(e; acc : String = '' | acc + if acc = '' then '' else '\r\n\t' endif + e.stmt) 97            ptext <- s.advStmt->iterate(e; acc : String = '' | acc + if acc = '' then '' else '\r\n\t' endif + e.stmt)
98        ) 98        )
99} 99}
100rule GenerateBeforeAdviceDummy extends AfterAdvice2Pattern{ 100rule GenerateBeforeAdviceDummy extends AfterAdvice2Pattern{
101    from 101    from
102        s : AFortran!AfterAdvice ( 102        s : APascal!AfterAdvice (
103            not s.aspect.advice->exists(e | e.oclIsKindOf(AFortran!BeforeAdvice)) 103            not s.aspect.advice->exists(e | e.oclIsKindOf(APascal!BeforeAdvice))
104        ) 104        )
105    to 105    to
106        t : RSL!Pattern, 106        t : RSL!Pattern,
107        bt: RSL!Pattern ( 107        bt: RSL!Pattern (
108            rsl <- s.aspect, 108            rsl <- s.aspect,
109            phead <- bph, 109            phead <- bph,
110            ptoken <- 'execution_part_construct_list', 110            ptoken <- 'statement_list',
111            ptext <- bspt 111            ptext <- bspt
112        ), 112        ),
113        bph : RSL!PatternHead ( 113        bph : RSL!PatternHead (
114            name <- 'before_advice_stmt' 114            name <- 'before_advice_stmt'
115        ), 115        ),
116        bspt : RSL!SimplePatternText ( 116        bspt : RSL!SimplePatternText (
117            ptext <- '' 117            ptext <- ''
118        ) 118        )
119} 119}
120  120 
121lazy rule PointCutExprToMethodName { 121lazy rule PointCutExprToMethodName {
122    from 122    from
123        s : AFortran!Expression 123        s : APascal!Expression
124    to 124    to
125        t : RSL!Pattern ( 125        t : RSL!Pattern (
126            ptext <- spt, 126            ptext <- spt,
127            ptoken <- 'NAME', 127            ptoken <- 'IDENTIFIER',
128            phead <- ph 128            phead <- ph
129        ), 129        ),
130        ph : RSL!PatternHead ( 130        ph : RSL!PatternHead (
131            name <-   'method_name' 131            name <-   'method_name'
132        ), 132        ),
133        spt : RSL!SimplePatternText ( 133        spt : RSL!SimplePatternText (
134        ptext <- ' '+ s.func_sub_Sig.name 134        ptext <- ' '+ s.funcOrProcSig.name
135        ) 135        )
136  136 
137} 137}
138lazy rule PointCutExprToWithinCode { 138lazy rule PointCutExprToWithinCode {
139    from 139    from
140        s : AFortran!Expression 140        s : APascal!Expression
141    to 141    to
142        t : RSL!Pattern ( 142        t : RSL!Pattern (
143            ptext <- spt , 143            ptext <- spt ,
144            ptoken <- 'NAME', 144            ptoken <- 'IDENTIFIER',
145            phead <- ph 145            phead <- ph
146        ), 146        ),
147        ph : RSL!PatternHead ( 147        ph : RSL!PatternHead (
148            name <-   'within_code' 148            name <-   'within_code'
149        ), 149        ),
150        spt : RSL!SimplePatternText ( 150        spt : RSL!SimplePatternText (
151        ptext <- if s.pointcut.pctexpr.size() > 1 then 151        ptext <- if s.pointcut.pctexpr.size() > 1 then
152                     ' '+ s.func_sub_Sig.name 152                     ' '+ s.funcOrProcSig.name
153                 else ' ' + 'mc_' endif 153                 else ' ' + 'mc_' endif
154  154 
155        ) 155        )
156} 156}
157  157 
158lazy rule PointCutToExternalPattern { 158lazy rule PointCutToExternalPattern {
159    from 159    from
160        s : AFortran!Pointcut 160        s : APascal!Pointcut
161    to 161    to
162        t : RSL!ExternalPattern ( 162        t : RSL!ExternalPattern (
163            dname <-  'FORTRAN', 163            dname <-  'ObjectPascal',
164            eptext <- 'around_advice_call', 164            eptext <- 'around_advice_call',
165            ptoken <- 'Fortran90_program', 165            ptoken <- 'ObjectPascal',
166            phead <- ph 166            phead <- ph
167        ), 167        ),
168        ph : RSL!PatternHead ( 168        ph : RSL!PatternHead (
169            name <-   'around_advice_call', 169            name <-   'around_advice_call',
170            params <- Sequence {pp1,pp2,pp3,pp4,pp5,pp6} 170            params <- Sequence {pp1,pp2,pp3,pp4,pp5,pp6}
171        ), 171        ),
172        pp1 : RSL!PatternParameter ( 172        pp1 : RSL!PatternParameter (
173            name <- 'program', 173            name <- 'program',
174            referTo <- 'Fortran90_program' 174            referTo <- 'ObjectPascal'
175        ), 175        ),
176        pp2 : RSL!PatternParameter ( 176        pp2 : RSL!PatternParameter (
177            name <- 'method_name', 177            name <- 'method_name',
178            referTo <- 'NAME' 178            referTo <- 'IDENTIFIER'
179        ), 179        ),
180        pp3 : RSL!PatternParameter ( 180        pp3 : RSL!PatternParameter (
181            name <- 'proceed_call', 181            name <- 'proceed_call',
182            referTo <- 'NAME' 182            referTo <- 'IDENTIFIER'
183        ), 183        ),
184        pp4 : RSL!PatternParameter ( 184        pp4 : RSL!PatternParameter (
185            name <- 'proceed_bef', 185            name <- 'proceed_bef',
186            referTo <- 'execution_part_construct_list' 186            referTo <- 'statement_list'
187        ), 187        ),
188        pp5 : RSL!PatternParameter ( 188        pp5 : RSL!PatternParameter (
189            name <- 'proceed_aft', 189            name <- 'proceed_aft',
190            referTo <- 'execution_part_construct_list' 190            referTo <- 'statement_list'
191        ), 191        ),
192        pp6 : RSL!PatternParameter ( 192        pp6 : RSL!PatternParameter (
193            name <- 'withincode', 193            name <- 'withincode',
194            referTo <- 'NAME' 194            referTo <- 'IDENTIFIER'
195        ) 195        )
196} 196}
197  197 
198lazy rule PointCutToRule { 198lazy rule PointCutToRule {
199    from 199    from
200        s : AFortran!Pointcut 200        s : APascal!Pointcut
201    to 201    to
202        t : RSL!Rule ( 202        t : RSL!Rule (
203  203 
204                rname <- s.name, 204                rname <- s.name,
205                type <-   'Fortran90_program', 205                type <-   'ObjectPascal',
206                params <- Sequence {rp1}, 206                params <- Sequence {rp1},
207                r_lhs_pattern <- rlhsp, 207                r_lhs_pattern <- rlhsp,
208                r_rhs_pattern <- rrhsp 208                r_rhs_pattern <- rrhsp
209            ), 209            ),
210            rp1: RSL!RuleParameter ( 210            rp1: RSL!RuleParameter (
211                name <- 'program', 211                name <- 'program',
212                referTo <- 'Fortran90_program' 212                referTo <- 'ObjectPascal'
213            ), 213            ),
214            rlhsp : RSL!RuleLHS ( 214            rlhsp : RSL!RuleLHS (
215                    ruletext <-   irt -- IDRuleText 215                    ruletext <-   irt -- IDRuleText
216            ), 216            ),
217            irt : RSL!IDRuleText ( 217            irt : RSL!IDRuleText (
218                text <- 'program' 218                text <- 'program'
219            ), 219            ),
220            rrhsp : RSL!RuleRHS ( 220            rrhsp : RSL!RuleRHS (
221                    ruletext <-   crt, -- ComplexRuleText 221                    ruletext <-   crt, -- ComplexRuleText
222                    condition <- Sequence {rcon} 222                    condition <- Sequence {rcon}
223            ), 223            ),
224            crt : RSL!ComplexRuleText ( 224            crt : RSL!ComplexRuleText (
225                pref <- rule_rhs_pattern 225                pref <- rule_rhs_pattern
226            ), 226            ),
227            rule_rhs_pattern : RSL!PatternRef ( 227            rule_rhs_pattern : RSL!PatternRef (
228                    name <-   'around_advice_call', 228                    name <-   'around_advice_call',
229                    params <- Sequence {param1,param2,param3,param4,param5,param6} 229                    params <- Sequence {param1,param2,param3,param4,param5,param6}
230            ), 230            ),
231            param1 : RSL!RealParameter ( 231            param1 : RSL!RealParameter (
232                      name <- 'program' 232                      name <- 'program'
233            ), 233            ),
234            param2 : RSL!PatternRef ( 234            param2 : RSL!PatternRef (
235                      name <- 'method_name' 235                      name <- 'method_name'
236            ), 236            ),
237  237 
238            param3 : RSL!PatternRef ( 238            param3 : RSL!PatternRef (
239                      name <- 'method_name' 239                      name <- 'method_name'
240            ), 240            ),
241            param4 : RSL!PatternRef ( 241            param4 : RSL!PatternRef (
242                      name <- 'before_advice_stmt' 242                      name <- 'before_advice_stmt'
243            ), 243            ),
244            param5 : RSL!PatternRef ( 244            param5 : RSL!PatternRef (
245                      name <- 'after_advice_stmt' 245                      name <- 'after_advice_stmt'
246            ), 246            ),
247            param6 : RSL!PatternRef ( 247            param6 : RSL!PatternRef (
248                      name <- 'within_code' 248                      name <- 'within_code'
249            ), 249            ),
250            rcon :  RSL!RuleNotEqCondition ( 250            rcon :  RSL!RuleNotEqCondition (
251                    lhs <- 'program', 251                    lhs <- 'program',
252                    pref <- rule_rhs_cond 252                    pref <- rule_rhs_cond
253            ), 253            ),
254            rule_rhs_cond : RSL!PatternRef ( 254            rule_rhs_cond : RSL!PatternRef (
255                    name <-   'around_advice_call', 255                    name <-   'around_advice_call',
256                    params <- Sequence {p1,p2,p3,p4,p5,p6} 256                    params <- Sequence {p1,p2,p3,p4,p5,p6}
257            ), 257            ),
258            p1 : RSL!RealParameter ( 258            p1 : RSL!RealParameter (
259                      name <- 'program' 259                      name <- 'program'
260            ), 260            ),
261            p2 : RSL!PatternRef ( 261            p2 : RSL!PatternRef (
262                      name <- 'method_name' 262                      name <- 'method_name'
263            ), 263            ),
264  264 
265            p3 : RSL!PatternRef ( 265            p3 : RSL!PatternRef (
266                      name <- 'method_name' 266                      name <- 'method_name'
267            ), 267            ),
268            p4 : RSL!PatternRef ( 268            p4 : RSL!PatternRef (
269                      name <- 'before_advice_stmt' 269                      name <- 'before_advice_stmt'
270            ), 270            ),
271            p5 : RSL!PatternRef ( 271            p5 : RSL!PatternRef (
272                      name <- 'after_advice_stmt' 272                      name <- 'after_advice_stmt'
273            ), 273            ),
274            p6 : RSL!PatternRef ( 274            p6 : RSL!PatternRef (
275                      name <- 'within_code' 275                      name <- 'within_code'
276            ) 276            )
277  277 
278  278 
279} 279}
280  280