← Back to branch summary

~ubuntu-branches/ubuntu/maverick/aspectc++/maverick

« 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
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20080410174052-xdnsm7oi8hauyyf1
Tags: 1.0pre4~svn.20080409+dfsg-3
Fix another missing include, this time in Ag++/StdSystem.cc

Show diffs side-by-side

added added

removed removed

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