← Back to branch summary

~ubuntu-branches/ubuntu/quantal/aspectc++/quantal

« back to all changes in this revision

Viewing changes to Puma/gen-release/step1/aspects/ExtACSyntaxCC.ah

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-04-10 17:40:52 UTC
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20080410174052-dbne39zue793jgrh
Tags: upstream-1.0pre4~svn.20080409+dfsg
Import upstream version 1.0pre4~svn.20080409+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
Puma/gen-release/step1/aspects/ExtACSyntaxCC.ah
26
26
// *************************
27
27
 
28
28
slice void ExtACSyntax::skip_pointcut_expr () {
29
 
  static int stop_tokens[] = { TOK_COLON, TOK_OPEN_CURLY, 0 };
 
29
  static int stop_tokens[] = { Puma::TOK_COLON, Puma::TOK_OPEN_CURLY, 0 };
30
30
  skip (stop_tokens, false);
31
31
}
32
32
 
33
 
slice CTree *ExtACSyntax::pointcut_decl () { 
 
33
slice Puma::CTree *ExtACSyntax::pointcut_decl () { 
34
34
  // 1: POINTCUT  decl
35
 
  if (!parse (TOK_POINTCUT)) return (CTree*)0;
 
35
  if (!parse (Puma::TOK_POINTCUT)) return (Puma::CTree*)0;
36
36
  semantic ().enter_pointcut_decl ();
37
 
  bool is_pointcut = parse (&CSyntax::decl);
 
37
  bool is_pointcut = parse (&Puma::CSyntax::decl);
38
38
  semantic ().leave_pointcut_decl ();
39
 
  return is_pointcut ? semantic ().introduce_pointcut () : (CTree*)0;
 
39
  return is_pointcut ? semantic ().introduce_pointcut () : (Puma::CTree*)0;
40
40
}
41
41
 
42
 
slice CTree *ExtACSyntax::class_slice_decl () { 
 
42
slice Puma::CTree *ExtACSyntax::class_slice_decl () { 
43
43
  // 1: SLICE class_key? identifier? { intro * } ;
44
 
  return (parse (TOK_SLICE) && class_key () &&
45
 
    (identifier () || parse (&CSyntax::private_name)) &&
46
 
    opt (parse (&CSyntax::class_slice_member_list))&& parse (TOK_SEMI_COLON)) ?
47
 
    semantic ().introduce_class_slice () : (CTree*)0;
48
 
}
49
 
 
50
 
slice CTree *ExtACSyntax::class_slice_member_decl () {
51
 
  return (parse (TOK_SLICE) && parse (&CSyntax::intro)) ?
52
 
    semantic ().introduce_class_slice_member () : (CTree*)0;
53
 
}
54
 
 
55
 
slice CTree *ExtACCSyntax::class_slice_decl () { 
 
44
  return (parse (Puma::TOK_SLICE) && class_key () &&
 
45
    (identifier () || parse (&Puma::CSyntax::private_name)) &&
 
46
    opt (parse (&Puma::CSyntax::class_slice_member_list))&& parse (Puma::TOK_SEMI_COLON)) ?
 
47
    semantic ().introduce_class_slice () : (Puma::CTree*)0;
 
48
}
 
49
 
 
50
slice Puma::CTree *ExtACSyntax::class_slice_member_decl () {
 
51
  return (parse (Puma::TOK_SLICE) && parse (&Puma::CSyntax::intro)) ?
 
52
    semantic ().introduce_class_slice_member () : (Puma::CTree*)0;
 
53
}
 
54
 
 
55
slice Puma::CTree *ExtACCSyntax::class_slice_decl () { 
56
56
  // 4-6: SLICE class_key class_slice_name base_clause? ({ intro * })? ;
57
 
  return (parse (TOK_SLICE) && class_key () &&
58
 
    parse (&CCSyntax::class_slice_name) &&
59
 
    opt (parse (&CCSyntax::class_slice_base_clause)) &&
60
 
    opt (parse (&CCSyntax::class_slice_member_list)) &&
61
 
    parse (TOK_SEMI_COLON)) ?
62
 
    semantic ().introduce_class_slice () : (CTree*)0;
 
57
  return (parse (Puma::TOK_SLICE) && class_key () &&
 
58
    parse (&Puma::CCSyntax::class_slice_name) &&
 
59
    opt (parse (&Puma::CCSyntax::class_slice_base_clause)) &&
 
60
    opt (parse (&Puma::CCSyntax::class_slice_member_list)) &&
 
61
    parse (Puma::TOK_SEMI_COLON)) ?
 
62
    semantic ().introduce_class_slice () : (Puma::CTree*)0;
63
63
}
64
64
 
65
 
slice CTree *ExtACCSyntax::class_slice_name () {
 
65
slice Puma::CTree *ExtACCSyntax::class_slice_name () {
66
66
  // 1: identifier
67
67
  // 2: nested_name_spec identifier
68
68
  // 2: :: identifier
69
69
  // 3: :: nested_name_spec identifier
70
70
  // 1: private_name
71
71
  bool ok = ((colon_colon (), nested_name_spec (), identifier ()) ||
72
 
            parse (&CSyntax::private_name));
 
72
            parse (&Puma::CSyntax::private_name));
73
73
  semantic ().reset_search_scope ();
74
 
  return ok ? builder ().class_slice_name () : (CTree*)0;
 
74
  return ok ? builder ().class_slice_name () : (Puma::CTree*)0;
75
75
}
76
76
 
77
 
slice CTree *ExtACCSyntax::class_slice_base_clause () { 
78
 
  if (!parse (TOK_COLON))
79
 
    return (CTree*)0;
 
77
slice Puma::CTree *ExtACCSyntax::class_slice_base_clause () { 
 
78
  if (!parse (Puma::TOK_COLON))
 
79
    return (Puma::CTree*)0;
80
80
  int tok;
81
81
  while ((tok = look_ahead ())) {
82
 
    if (tok == TOK_OPEN_CURLY || tok == TOK_SEMI_COLON)
 
82
    if (tok == Puma::TOK_OPEN_CURLY || tok == Puma::TOK_SEMI_COLON)
83
83
      break;
84
84
    else
85
85
      consume ();
87
87
  return builder ().intro ();
88
88
}
89
89
 
90
 
slice CTree *ExtACSyntax::class_slice_member_list () {
91
 
  return (parse (TOK_OPEN_CURLY) && opt (seq (&CSyntax::intro)) &&
92
 
    parse (TOK_CLOSE_CURLY)) ?
93
 
    builder ().class_slice_member_list () : (CTree*)0;
 
90
slice Puma::CTree *ExtACSyntax::class_slice_member_list () {
 
91
  return (parse (Puma::TOK_OPEN_CURLY) && opt (seq (&Puma::CSyntax::intro)) &&
 
92
    parse (Puma::TOK_CLOSE_CURLY)) ?
 
93
    builder ().class_slice_member_list () : (Puma::CTree*)0;
94
94
}
95
95
 
96
 
slice CTree *ExtACSyntax::order_decl () {
97
 
  return (parse (TOK_ID) &&
 
96
slice Puma::CTree *ExtACSyntax::order_decl () {
 
97
  return (parse (Puma::TOK_ID) &&
98
98
          strcmp (builder ().get_node ()->token ()->text (), "order") == 0 &&
99
 
          parse (&CSyntax::order_list) &&
100
 
          parse (TOK_SEMI_COLON)) ? builder ().order_decl () : (CTree*)0;
101
 
}
102
 
 
103
 
slice CTree *ExtACSyntax::order_list () {
104
 
  return (parse (TOK_OPEN_ROUND) &&
105
 
          opt (list (&CSyntax::pointcut_expr, TOK_COMMA)) &&
106
 
          parse (TOK_CLOSE_ROUND)) ? builder ().order_list () : (CTree*)0;
107
 
}
108
 
 
109
 
slice CTree *ExtACSyntax::advice_decl () { 
 
99
          parse (&Puma::CSyntax::order_list) &&
 
100
          parse (Puma::TOK_SEMI_COLON)) ? builder ().order_decl () : (Puma::CTree*)0;
 
101
}
 
102
 
 
103
slice Puma::CTree *ExtACSyntax::order_list () {
 
104
  return (parse (Puma::TOK_OPEN_ROUND) &&
 
105
          opt (list (&Puma::CSyntax::pointcut_expr, Puma::TOK_COMMA)) &&
 
106
          parse (Puma::TOK_CLOSE_ROUND)) ? builder ().order_list () : (Puma::CTree*)0;
 
107
}
 
108
 
 
109
slice Puma::CTree *ExtACSyntax::advice_decl () { 
110
110
  // 1: ADVICE  pointcut  :  decl
111
 
  if (!parse (TOK_ADVICE)) return (CTree*)0;
 
111
  if (!parse (Puma::TOK_ADVICE)) return (Puma::CTree*)0;
112
112
  semantic ().enter_advice_decl ();
113
 
  State before_expr = token_provider->get_state ();
 
113
  Syntax::State before_expr = token_provider->get_state ();
114
114
  skip_pointcut_expr ();
115
 
  bool ok = (parse (TOK_COLON) && 
116
 
             (parse (&CSyntax::order_decl) ||
117
 
              parse (&CSyntax::slice_ref) ||
118
 
              parse (&CSyntax::class_slice_decl) ||
119
 
              parse (&CSyntax::intro) ||
120
 
              parse (&CSyntax::decl)));
 
115
  bool ok = (parse (Puma::TOK_COLON) && 
 
116
             (parse (&Puma::CSyntax::order_decl) ||
 
117
              parse (&Puma::CSyntax::slice_ref) ||
 
118
              parse (&Puma::CSyntax::class_slice_decl) ||
 
119
              parse (&Puma::CSyntax::intro) ||
 
120
              parse (&Puma::CSyntax::decl)));
121
121
  if (ok) {
122
122
    semantic ().enter_pointcut_expr ();
123
123
    token_provider->set_state (before_expr);
124
 
    ok = parse (&CSyntax::pointcut_expr);
 
124
    ok = parse (&Puma::CSyntax::pointcut_expr);
125
125
    semantic ().leave_pointcut_expr ();
126
126
  }
127
127
  semantic ().leave_advice_decl ();
128
 
  return ok ? semantic ().introduce_advice () : (CTree*)0;
 
128
  return ok ? semantic ().introduce_advice () : (Puma::CTree*)0;
129
129
}
130
130
 
131
 
slice CTree *ExtACSyntax::pointcut_expr () { 
 
131
slice Puma::CTree *ExtACSyntax::pointcut_expr () { 
132
132
  // 1: const_expr
133
 
  return (parse (&CSyntax::const_expr)) ? 
134
 
    builder ().pointcut_expr () : (CTree*)0;
 
133
  return (parse (&Puma::CSyntax::const_expr)) ? 
 
134
    builder ().pointcut_expr () : (Puma::CTree*)0;
135
135
}
136
136
 
137
 
slice CTree *ExtACSyntax::pointcut_member_decl () {
 
137
slice Puma::CTree *ExtACSyntax::pointcut_member_decl () {
138
138
  // 1: POINTCUT  decl
139
 
  if (!parse (TOK_POINTCUT)) return (CTree*)0;
 
139
  if (!parse (Puma::TOK_POINTCUT)) return (Puma::CTree*)0;
140
140
  semantic ().enter_pointcut_decl ();
141
 
  bool is_pointcut = parse (&CSyntax::member_decl);
 
141
  bool is_pointcut = parse (&Puma::CSyntax::member_decl);
142
142
  semantic ().leave_pointcut_decl ();
143
 
  return is_pointcut ? semantic ().introduce_pointcut () : (CTree*)0;
 
143
  return is_pointcut ? semantic ().introduce_pointcut () : (Puma::CTree*)0;
144
144
}
145
145
 
146
 
slice CTree *ExtACSyntax::advice_member_decl () {
 
146
slice Puma::CTree *ExtACSyntax::advice_member_decl () {
147
147
  // 1: ADVICE  pointcut  :  decl 
148
 
  if (!parse (TOK_ADVICE)) return (CTree*)0;
 
148
  if (!parse (Puma::TOK_ADVICE)) return (Puma::CTree*)0;
149
149
  semantic ().enter_advice_decl ();
150
 
  State before_expr = token_provider->get_state ();
 
150
  Syntax::State before_expr = token_provider->get_state ();
151
151
  skip_pointcut_expr ();
152
 
  bool ok = (parse (TOK_COLON) && 
153
 
             (parse (&CSyntax::order_decl) ||
154
 
              parse (&CSyntax::slice_ref) ||
155
 
              parse (&CSyntax::class_slice_decl) ||
156
 
              parse (&CSyntax::intro) ||
157
 
              parse (&CSyntax::member_decl)));
 
152
  bool ok = (parse (Puma::TOK_COLON) && 
 
153
             (parse (&Puma::CSyntax::order_decl) ||
 
154
              parse (&Puma::CSyntax::slice_ref) ||
 
155
              parse (&Puma::CSyntax::class_slice_decl) ||
 
156
              parse (&Puma::CSyntax::intro) ||
 
157
              parse (&Puma::CSyntax::member_decl)));
158
158
  if (ok) {
159
159
    semantic ().enter_pointcut_expr ();
160
160
    token_provider->set_state (before_expr);
161
 
    ok = parse (&CSyntax::pointcut_expr);
 
161
    ok = parse (&Puma::CSyntax::pointcut_expr);
162
162
    semantic ().leave_pointcut_expr ();
163
163
  }
164
164
  semantic ().leave_advice_decl ();
165
 
  return ok ? semantic ().introduce_member_advice () : (CTree*)0;
 
165
  return ok ? semantic ().introduce_member_advice () : (Puma::CTree*)0;
166
166
}
167
167
 
168
 
slice CTree *ExtACSyntax::slice_ref () {
 
168
slice Puma::CTree *ExtACSyntax::slice_ref () {
169
169
  // 3: SLICE  identifier  ;
170
 
  return (parse (TOK_SLICE) && identifier () && parse (TOK_SEMI_COLON)) ?
171
 
    builder ().slice_ref () : (CTree*)0;
 
170
  return (parse (Puma::TOK_SLICE) && identifier () && parse (Puma::TOK_SEMI_COLON)) ?
 
171
    builder ().slice_ref () : (Puma::CTree*)0;
172
172
}
173
173
 
174
 
slice CTree *ExtACCSyntax::slice_ref () {
 
174
slice Puma::CTree *ExtACCSyntax::slice_ref () {
175
175
  // 3: SLICE  class_name  ;
176
176
  // 4: SLICE  ::  class_name ;
177
177
  // 4: SLICE  nested_name_spec  class_name  ;
178
178
  // 5: SLICE  ::  nested_name_spec  class_name  ;
179
 
  if (! parse (TOK_SLICE))
180
 
    return (CTree*)0;
 
179
  if (! parse (Puma::TOK_SLICE))
 
180
    return (Puma::CTree*)0;
181
181
  bool ok = ((colon_colon (), nested_name_spec (), class_name ()) &&
182
 
    parse (TOK_SEMI_COLON));
 
182
    parse (Puma::TOK_SEMI_COLON));
183
183
  semantic ().reset_search_scope ();
184
 
  return ok ? builder ().slice_ref () : (CTree*)0;
 
184
  return ok ? builder ().slice_ref () : (Puma::CTree*)0;
185
185
}
186
186
 
187
 
slice CTree *ExtACSyntax::intro () {
188
 
  if (look_ahead () == TOK_CLOSE_CURLY)
189
 
    return (CTree*)0;
 
187
slice Puma::CTree *ExtACSyntax::intro () {
 
188
  if (look_ahead () == Puma::TOK_CLOSE_CURLY)
 
189
    return (Puma::CTree*)0;
190
190
 
191
 
  if (parse (TOK_ID)) {
 
191
  if (parse (Puma::TOK_ID)) {
192
192
    const char *id = builder ().get_node ()->token ()->text ();
193
193
    if (strcmp (id, "order") == 0 ||
194
194
        strcmp (id, "before") == 0 ||
195
195
        strcmp (id, "after") == 0 ||
196
196
        strcmp (id, "around") == 0 ||
197
197
        strcmp (id, "baseclass") == 0)
198
 
      return (CTree*)0;
 
198
      return (Puma::CTree*)0;
199
199
  }
200
200
  
201
 
  if (parse (TOK_PRIVATE) || parse (TOK_PROTECTED) || parse (TOK_PUBLIC)) {
202
 
    return parse (TOK_COLON) ? builder ().intro () : (CTree*)0;
 
201
  if (parse (Puma::TOK_PRIVATE) || parse (Puma::TOK_PROTECTED) || parse (Puma::TOK_PUBLIC)) {
 
202
    return parse (Puma::TOK_COLON) ? builder ().intro () : (Puma::CTree*)0;
203
203
  }
204
204
  
205
205
  // look ahead 
207
207
  int tok;
208
208
  while ((tok = look_ahead ())) {
209
209
    // end of intro reached?
210
 
    if (tok == TOK_SEMI_COLON && !is_fct) {
 
210
    if (tok == Puma::TOK_SEMI_COLON && !is_fct) {
211
211
      consume ();
212
212
      break;
213
213
    }
214
214
    
215
 
    if (tok == TOK_OPEN_CURLY) {
 
215
    if (tok == Puma::TOK_OPEN_CURLY) {
216
216
      parse_curly_block ();
217
217
      if (is_fct)
218
218
        break;
219
219
    }
220
 
    else if (tok == TOK_OPEN_ROUND)
 
220
    else if (tok == Puma::TOK_OPEN_ROUND)
221
221
      parse_round_block ();
222
222
    else
223
223
      consume ();