← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/aspectc++/jaunty

« back to all changes in this revision

Viewing changes to Puma/gen-release/step2/inc/Puma/PreTreeNodes.h

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-07-07 14:41:02 UTC
  • mfrom: (1.1.3 upstream) (6.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080707144102-lzml7t07f3sl00r5
Tags: 1.0pre4~svn.20080711-1
http://bugs.debian.org/480316
* new upstream snapshot.
* include all upstream documentation. Clarifying emails regarding
  licensing has been included into debian/copyright.
* reformat description following recomendations of
  http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Description
  (Closes: #480316)

Show diffs side-by-side

added added

removed removed

Lines of Context:
Puma/gen-release/step2/inc/Puma/PreTreeNodes.h
1
 
#ifndef __ac_FIRST__var_tmp_aspectc4343_debian_Puma_gen45release_step1__
2
 
#define __ac_FIRST__var_tmp_aspectc4343_debian_Puma_gen45release_step1__
3
 
#define __ac_FIRST_FILE__var_tmp_aspectc4343_debian_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
 
1
#ifndef __ac_FIRST__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1__
 
2
#define __ac_FIRST__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1__
 
3
#define __ac_FIRST_FILE__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
4
4
 
5
5
#ifndef __ac_h_
6
6
#define __ac_h_
33
33
    typedef typename TL::type Type;
34
34
    typedef typename Referred<Type>::type ReferredType;
35
35
  };
 
36
  template <typename T> int ttest(...);
 
37
  template <typename T> char ttest(typename T::__AttrTypes const volatile *);
 
38
  template<typename T> struct HasTypeInfo {
 
39
    enum { RET=((sizeof(ttest<T>(0))==1)?1:0) };
 
40
  };
 
41
  template<typename T, int HAVE = HasTypeInfo<T>::RET> struct TypeInfo {
 
42
    enum { AVAILABLE = 0 };
 
43
  };
 
44
  template<typename T> struct TypeInfo<T, 1> {
 
45
    enum { AVAILABLE = 1 };
 
46
    enum { ELEMENTS = T::__AttrTypes::ARGS };
 
47
    template<int I>
 
48
    struct Member : public AC::Arg<typename T::__AttrTypes,I> {};
 
49
    template<int I>
 
50
    static typename Member<I>::ReferredType* member (T* obj) {
 
51
      return (typename Member<I>::ReferredType*)obj->__attr (I);
 
52
    }
 
53
    static const char *member_name (T &obj, int i) {
 
54
      return obj.__attr_name (i);
 
55
    }
 
56
         };
36
57
  template <class Aspect, int Index>
37
58
  struct CFlow {
38
59
    static int &instance () {
48
69
inline void operator delete (void *, AC::AnyResultBuffer *) { } // for VC++
49
70
#endif // __cplusplus
50
71
#endif // __ac_h_
51
 
#endif // __ac_FIRST__var_tmp_aspectc4343_debian_Puma_gen45release_step1__
 
72
#endif // __ac_FIRST__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1__
52
73
 
53
 
#line 1 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
74
#line 1 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
54
75
// This file is part of PUMA.
55
76
// Copyright (C) 1999-2003  The PUMA developer team.
56
77
//                                                                
72
93
#ifndef __pre_syntax_tree_nodes__
73
94
#define __pre_syntax_tree_nodes__
74
95
 
75
 
// Contains all node classes for the preprocessor syntax tree.
 
96
/** \file 
 
97
 *  Preprocessor syntax tree classes. */
76
98
 
77
99
#include "Puma/Unit.h"
78
100
#include "Puma/PreVisitor.h"
82
104
namespace Puma {
83
105
 
84
106
 
85
 
// The root node of the preprocessor syntax tree.
 
107
/** \class PreProgram PreTreeNodes.h Puma/PreTreeNodes.h
 
108
 *  The root node of the preprocessor syntax tree. */
86
109
 
87
 
#line 88 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
110
#line 111 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
88
111
} // closed Puma
89
112
class CCExprResolve;
90
113
class CExprResolve;
107
130
class CMatchSyntax;
108
131
namespace Puma {
109
132
 
110
 
#line 33 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
133
#line 35 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
111
134
class PreProgram : public PreTreeComposite {
112
 
#line 113 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
135
#line 136 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
113
136
  friend class ::CCExprResolve;
114
137
  friend class ::CExprResolve;
115
138
  friend class ::WinIfExists;
130
153
  friend class ::PragmaOnce;
131
154
  friend class ::CMatchSyntax;
132
155
 
133
 
#line 33 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
156
#line 35 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
134
157
 
135
158
public:
136
 
  PreProgram (PreTree* a) : PreTreeComposite (1, 0) 
137
 
    { add_son (a); };
 
159
  /** Constructor.
 
160
   *  \param g The group of preprocessor directives. */
 
161
  PreProgram (PreTree* g) : PreTreeComposite (1, 0) { 
 
162
    add_son (g); 
 
163
  }
138
164
 
 
165
  /** Part of the tree visitor pattern. Calls the node
 
166
   *  visiting functions suitable for this node type. 
 
167
   *  \param v The visitor object on which to call the 
 
168
   *           visiting functions. */
139
169
  void accept (PreVisitor &v) {
140
170
    v.visitPreProgram_Pre (this);
141
171
    v.iterateNodes (this);
142
172
    v.visitPreProgram_Post (this);
143
173
  }            
 
174
public:
 
175
  typedef AC::TLE __AttrTypes;
 
176
  const char *__attr_name (unsigned i) const { return 0; }
 
177
  const void *__attr (unsigned __i) const { return 0; }
 
178
#line 52 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
144
179
};      
145
180
 
146
181
 
147
 
// Assemble groups of directive groups to a `super' group => the program.
 
182
/** \class PreDirectiveGroups PreTreeNodes.h Puma/PreTreeNodes.h
 
183
 *  Preprocessor tree node representing the directive groups in the program. */
148
184
 
149
 
#line 150 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
185
#line 186 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
150
186
} // closed Puma
151
187
class CCExprResolve;
152
188
class CExprResolve;
169
205
class CMatchSyntax;
170
206
namespace Puma {
171
207
 
172
 
#line 47 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
208
#line 57 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
173
209
class PreDirectiveGroups : public PreTreeComposite {
174
 
#line 175 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
210
#line 211 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
175
211
  friend class ::CCExprResolve;
176
212
  friend class ::CExprResolve;
177
213
  friend class ::WinIfExists;
192
228
  friend class ::PragmaOnce;
193
229
  friend class ::CMatchSyntax;
194
230
 
195
 
#line 47 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
231
#line 57 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
196
232
 
197
233
public:
198
 
  PreDirectiveGroups () : PreTreeComposite (-1, 0) {};
 
234
  /** Constructor. */
 
235
  PreDirectiveGroups () : PreTreeComposite (-1, 0) {}
199
236
 
 
237
  /** Part of the tree visitor pattern. Calls the node
 
238
   *  visiting functions suitable for this node type. 
 
239
   *  \param v The visitor object on which to call the 
 
240
   *           visiting functions. */
200
241
  void accept (PreVisitor& v) {
201
242
    v.visitPreDirectiveGroups_Pre (this);
202
243
    v.iterateNodes (this);
203
244
    v.visitPreDirectiveGroups_Post (this);
204
245
  }            
 
246
public:
 
247
  typedef AC::TLE __AttrTypes;
 
248
  const char *__attr_name (unsigned i) const { return 0; }
 
249
  const void *__attr (unsigned __i) const { return 0; }
 
250
#line 71 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
205
251
};      
206
252
 
207
253
 
208
 
// Assemble conditional directives to a logical group.
209
 
// Like: #if ... #elif ... #else ... #endif.
 
254
/** \class PreConditionalGroup PreTreeNodes.h Puma/PreTreeNodes.h
 
255
 *  Preprocessor tree node representing a group of conditional directives. 
 
256
 *  Example: \code #if ... #elif ... #else ... #endif \endcode */
210
257
 
211
 
#line 212 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
258
#line 259 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
212
259
} // closed Puma
213
260
class CCExprResolve;
214
261
class CExprResolve;
231
278
class CMatchSyntax;
232
279
namespace Puma {
233
280
 
234
 
#line 61 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
281
#line 77 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
235
282
class PreConditionalGroup : public PreTreeComposite {
236
 
#line 237 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
283
#line 284 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
237
284
  friend class ::CCExprResolve;
238
285
  friend class ::CExprResolve;
239
286
  friend class ::WinIfExists;
254
301
  friend class ::PragmaOnce;
255
302
  friend class ::CMatchSyntax;
256
303
 
257
 
#line 61 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
304
#line 77 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
258
305
 
259
306
public:
260
 
  PreConditionalGroup (PreTree* a, PreTree* b, PreTree* c) : 
261
 
    PreTreeComposite (3, 0) // 3 sons, no daughters.
262
 
    { add_son (a); add_son (b); add_son (c); };
263
 
        
264
 
  PreConditionalGroup (PreTree* a, PreTree* b, PreTree* c, PreTree* d) : 
265
 
    PreTreeComposite (4, 0) // 4 sons, no daughters.
266
 
    { add_son (a); add_son (b); add_son (c); add_son (d); };
 
307
  /** Constructor. 
 
308
   *  \param i The \#if part.
 
309
   *  \param dg The directive group.
 
310
   *  \param ei The \#endif part. */
 
311
  PreConditionalGroup (PreTree* i, PreTree* dg, PreTree* ei) : PreTreeComposite (3, 0) { 
 
312
    add_son (i); add_son (dg); add_son (ei); 
 
313
  }
 
314
  /** Constructor. 
 
315
   *  \param i The \#if part.
 
316
   *  \param e The \#elif or \#else part.
 
317
   *  \param dg The directive group.
 
318
   *  \param ei The \#endif part. */
 
319
  PreConditionalGroup (PreTree* i, PreTree* e, PreTree* dg, PreTree* ei) : PreTreeComposite (4, 0) { 
 
320
    add_son (i); add_son (e); add_son (dg); add_son (ei); 
 
321
  }
267
322
 
 
323
  /** Part of the tree visitor pattern. Calls the node
 
324
   *  visiting functions suitable for this node type. 
 
325
   *  \param v The visitor object on which to call the 
 
326
   *           visiting functions. */
268
327
  void accept (PreVisitor& v) {
269
328
    v.visitPreConditionalGroup_Pre (this);
270
329
    v.iterateNodes (this);
271
330
    v.visitPreConditionalGroup_Post (this);
272
331
  }
 
332
public:
 
333
  typedef AC::TLE __AttrTypes;
 
334
  const char *__attr_name (unsigned i) const { return 0; }
 
335
  const void *__attr (unsigned __i) const { return 0; }
 
336
#line 104 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
273
337
};      
274
338
 
275
339
 
276
 
// Assemble conditional directives within the else part of a 
277
 
// conditional group to a logical group.
278
 
// Like: ... #elif ... #elif ... #elif ... #else.
 
340
/** \class PreElsePart PreTreeNodes.h Puma/PreTreeNodes.h
 
341
 *  Preprocessor tree node representing a group of directives 
 
342
 *  in the \#else part of an \#if conditional. */
279
343
 
280
 
#line 281 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
344
#line 345 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
281
345
} // closed Puma
282
346
class CCExprResolve;
283
347
class CExprResolve;
300
364
class CMatchSyntax;
301
365
namespace Puma {
302
366
 
303
 
#line 82 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
367
#line 110 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
304
368
class PreElsePart : public PreTreeComposite {
305
 
#line 306 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
369
#line 370 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
306
370
  friend class ::CCExprResolve;
307
371
  friend class ::CExprResolve;
308
372
  friend class ::WinIfExists;
323
387
  friend class ::PragmaOnce;
324
388
  friend class ::CMatchSyntax;
325
389
 
326
 
#line 82 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
390
#line 110 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
327
391
 
328
392
public:
329
 
  PreElsePart (PreTree* a, PreTree* b) : 
330
 
    PreTreeComposite (2, 0) // 2 sons, no daughters.
331
 
    { add_son (a); add_son (b); };
332
 
                                        
333
 
  PreElsePart (PreTree* a, PreTree* b, PreTree* c) : 
334
 
    PreTreeComposite (3, 0) // 3 sons, no daughters.
335
 
    { add_son (a); add_son (b); add_son (c); };
 
393
  /** Constructor. 
 
394
   *  \param dg The directive group.
 
395
   *  \param el The \#else directive. */
 
396
  PreElsePart (PreTree* dg, PreTree* el) : PreTreeComposite (2, 0) { 
 
397
    add_son (dg); add_son (el); 
 
398
  }
 
399
  /** Constructor. 
 
400
   *  \param ei The preceding \#elif part.
 
401
   *  \param dg The directive group.
 
402
   *  \param el The \#else directive. */
 
403
  PreElsePart (PreTree* ei, PreTree* dg, PreTree* el) : PreTreeComposite (3, 0) { 
 
404
    add_son (ei); add_son (dg); add_son (el); 
 
405
  }
336
406
 
 
407
  /** Part of the tree visitor pattern. Calls the node
 
408
   *  visiting functions suitable for this node type. 
 
409
   *  \param v The visitor object on which to call the 
 
410
   *           visiting functions. */
337
411
  void accept (PreVisitor& v) {
338
412
    v.visitPreElsePart_Pre (this);
339
413
    v.iterateNodes (this);
340
414
    v.visitPreElsePart_Post (this);
341
415
  }
342
 
};      
343
 
 
344
 
 
345
 
// Assemble conditional directives in the elif part of a conditional 
346
 
// group to a logical group.
347
 
// Like: ... #elif ... #elif ... #elif.
348
 
 
349
 
#line 350 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
350
 
} // closed Puma
351
 
class CCExprResolve;
352
 
class CExprResolve;
353
 
class WinIfExists;
354
 
class WinImportHandler;
355
 
class WinMacros;
356
 
class WinAsm;
357
 
class WinDeclSpecs;
358
 
class WinMemberExplSpec;
359
 
class WinTypeKeywords;
360
 
class WinFriend;
361
 
class ExtAC;
362
 
class ExtACBuilderCoupling;
363
 
class ExtACSyntaxCoupling;
364
 
class ExtACTree;
365
 
class ExtACKeywords;
366
 
class ExtGnu;
367
 
class PragmaOnceUnitState;
368
 
class PragmaOnce;
369
 
class CMatchSyntax;
370
 
namespace Puma {
371
 
 
372
 
#line 103 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
373
 
class PreElifPart : public PreTreeComposite
374
 
 {
375
 
#line 376 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
376
 
  friend class ::CCExprResolve;
377
 
  friend class ::CExprResolve;
378
 
  friend class ::WinIfExists;
379
 
  friend class ::WinImportHandler;
380
 
  friend class ::WinMacros;
381
 
  friend class ::WinAsm;
382
 
  friend class ::WinDeclSpecs;
383
 
  friend class ::WinMemberExplSpec;
384
 
  friend class ::WinTypeKeywords;
385
 
  friend class ::WinFriend;
386
 
  friend class ::ExtAC;
387
 
  friend class ::ExtACBuilderCoupling;
388
 
  friend class ::ExtACSyntaxCoupling;
389
 
  friend class ::ExtACTree;
390
 
  friend class ::ExtACKeywords;
391
 
  friend class ::ExtGnu;
392
 
  friend class ::PragmaOnceUnitState;
393
 
  friend class ::PragmaOnce;
394
 
  friend class ::CMatchSyntax;
395
 
 
396
 
#line 104 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
397
 
 
398
 
    public:
399
 
                                // Dynamic sons, no daughters.
400
 
        PreElifPart () : PreTreeComposite (-1, 0) {};
401
 
        
402
 
        // Add two sons.
403
 
        void addSons (PreTree* a, PreTree* b)
404
 
            { add_son (a); add_son (b); };
405
 
 
406
 
        void accept (PreVisitor& v)
407
 
        {
408
 
            v.visitPreElifPart_Pre (this);
409
 
            v.iterateNodes (this);
410
 
            v.visitPreElifPart_Post (this);
411
 
        }
412
 
 };      
413
 
 
414
 
 
415
 
// The #if directive.
416
 
 
417
 
#line 418 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
418
 
} // closed Puma
419
 
class CCExprResolve;
420
 
class CExprResolve;
421
 
class WinIfExists;
422
 
class WinImportHandler;
423
 
class WinMacros;
424
 
class WinAsm;
425
 
class WinDeclSpecs;
426
 
class WinMemberExplSpec;
427
 
class WinTypeKeywords;
428
 
class WinFriend;
429
 
class ExtAC;
430
 
class ExtACBuilderCoupling;
431
 
class ExtACSyntaxCoupling;
432
 
class ExtACTree;
433
 
class ExtACKeywords;
434
 
class ExtGnu;
435
 
class PragmaOnceUnitState;
436
 
class PragmaOnce;
437
 
class CMatchSyntax;
438
 
namespace Puma {
439
 
 
440
 
#line 123 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
441
 
class PreIfDirective : public PreTreeComposite
442
 
 {
443
 
#line 444 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
444
 
  friend class ::CCExprResolve;
445
 
  friend class ::CExprResolve;
446
 
  friend class ::WinIfExists;
447
 
  friend class ::WinImportHandler;
448
 
  friend class ::WinMacros;
449
 
  friend class ::WinAsm;
450
 
  friend class ::WinDeclSpecs;
451
 
  friend class ::WinMemberExplSpec;
452
 
  friend class ::WinTypeKeywords;
453
 
  friend class ::WinFriend;
454
 
  friend class ::ExtAC;
455
 
  friend class ::ExtACBuilderCoupling;
456
 
  friend class ::ExtACSyntaxCoupling;
457
 
  friend class ::ExtACTree;
458
 
  friend class ::ExtACKeywords;
459
 
  friend class ::ExtGnu;
460
 
  friend class ::PragmaOnceUnitState;
461
 
  friend class ::PragmaOnce;
462
 
  friend class ::CMatchSyntax;
463
 
 
464
 
#line 124 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
465
 
 
466
 
    public:
467
 
                                        
468
 
        PreIfDirective (PreTree* a, PreTree* b) 
469
 
                        : PreTreeComposite (2, 1) // 2 sons, 1 daughter.
470
 
            { add_son (a); add_son (b); };
471
 
 
472
 
        void accept (PreVisitor& v)
473
 
        {
474
 
            v.visitPreIfDirective_Pre (this);
475
 
            v.iterateNodes (this);
476
 
            v.visitPreIfDirective_Post (this);
477
 
        }
478
 
 };      
479
 
 
480
 
 
481
 
// The #ifdef directive.
482
 
 
483
 
#line 484 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
484
 
} // closed Puma
485
 
class CCExprResolve;
486
 
class CExprResolve;
487
 
class WinIfExists;
488
 
class WinImportHandler;
489
 
class WinMacros;
490
 
class WinAsm;
491
 
class WinDeclSpecs;
492
 
class WinMemberExplSpec;
493
 
class WinTypeKeywords;
494
 
class WinFriend;
495
 
class ExtAC;
496
 
class ExtACBuilderCoupling;
497
 
class ExtACSyntaxCoupling;
498
 
class ExtACTree;
499
 
class ExtACKeywords;
500
 
class ExtGnu;
501
 
class PragmaOnceUnitState;
502
 
class PragmaOnce;
503
 
class CMatchSyntax;
504
 
namespace Puma {
505
 
 
506
 
#line 141 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
507
 
class PreIfdefDirective : public PreTreeComposite
508
 
 {
509
 
#line 510 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
510
 
  friend class ::CCExprResolve;
511
 
  friend class ::CExprResolve;
512
 
  friend class ::WinIfExists;
513
 
  friend class ::WinImportHandler;
514
 
  friend class ::WinMacros;
515
 
  friend class ::WinAsm;
516
 
  friend class ::WinDeclSpecs;
517
 
  friend class ::WinMemberExplSpec;
518
 
  friend class ::WinTypeKeywords;
519
 
  friend class ::WinFriend;
520
 
  friend class ::ExtAC;
521
 
  friend class ::ExtACBuilderCoupling;
522
 
  friend class ::ExtACSyntaxCoupling;
523
 
  friend class ::ExtACTree;
524
 
  friend class ::ExtACKeywords;
525
 
  friend class ::ExtGnu;
526
 
  friend class ::PragmaOnceUnitState;
527
 
  friend class ::PragmaOnce;
528
 
  friend class ::CMatchSyntax;
529
 
 
530
 
#line 142 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
531
 
 
532
 
    public:
533
 
                                        
534
 
        PreIfdefDirective (PreTree* a, PreTree* b, PreTree* c) 
535
 
                        : PreTreeComposite (3, 1) // 3 sons, 1 daughter.
536
 
            { add_son (a); add_son (b); add_son (c); };
537
 
        PreIfdefDirective (PreTree* a, PreTree* b) 
538
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughter.
539
 
            { add_son (a); add_son (b); };
540
 
 
541
 
        void accept (PreVisitor& v)
542
 
        {
543
 
            v.visitPreIfdefDirective_Pre (this);
544
 
            v.iterateNodes (this);
545
 
            v.visitPreIfdefDirective_Post (this);
546
 
        }
547
 
 };      
548
 
 
549
 
 
550
 
// The #ifndef directive.
551
 
 
552
 
#line 553 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
553
 
} // closed Puma
554
 
class CCExprResolve;
555
 
class CExprResolve;
556
 
class WinIfExists;
557
 
class WinImportHandler;
558
 
class WinMacros;
559
 
class WinAsm;
560
 
class WinDeclSpecs;
561
 
class WinMemberExplSpec;
562
 
class WinTypeKeywords;
563
 
class WinFriend;
564
 
class ExtAC;
565
 
class ExtACBuilderCoupling;
566
 
class ExtACSyntaxCoupling;
567
 
class ExtACTree;
568
 
class ExtACKeywords;
569
 
class ExtGnu;
570
 
class PragmaOnceUnitState;
571
 
class PragmaOnce;
572
 
class CMatchSyntax;
573
 
namespace Puma {
574
 
 
575
 
#line 162 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
576
 
class PreIfndefDirective : public PreTreeComposite
577
 
 {
578
 
#line 579 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
579
 
  friend class ::CCExprResolve;
580
 
  friend class ::CExprResolve;
581
 
  friend class ::WinIfExists;
582
 
  friend class ::WinImportHandler;
583
 
  friend class ::WinMacros;
584
 
  friend class ::WinAsm;
585
 
  friend class ::WinDeclSpecs;
586
 
  friend class ::WinMemberExplSpec;
587
 
  friend class ::WinTypeKeywords;
588
 
  friend class ::WinFriend;
589
 
  friend class ::ExtAC;
590
 
  friend class ::ExtACBuilderCoupling;
591
 
  friend class ::ExtACSyntaxCoupling;
592
 
  friend class ::ExtACTree;
593
 
  friend class ::ExtACKeywords;
594
 
  friend class ::ExtGnu;
595
 
  friend class ::PragmaOnceUnitState;
596
 
  friend class ::PragmaOnce;
597
 
  friend class ::CMatchSyntax;
598
 
 
599
 
#line 163 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
600
 
 
601
 
    public:
602
 
                                        
603
 
        PreIfndefDirective (PreTree* a, PreTree* b, PreTree* c) 
604
 
                        : PreTreeComposite (3, 1) // 3 sons, 1 daughter.
605
 
            { add_son (a); add_son (b); add_son (c); };
606
 
        PreIfndefDirective (PreTree* a, PreTree* b) 
607
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughter.
608
 
            { add_son (a); add_son (b); };
609
 
 
610
 
        void accept (PreVisitor& v)
611
 
        {
612
 
            v.visitPreIfndefDirective_Pre (this);
613
 
            v.iterateNodes (this);
614
 
            v.visitPreIfndefDirective_Post (this);
615
 
        }
616
 
 };      
617
 
 
618
 
 
619
 
// The #elif directive.
620
 
 
621
 
#line 622 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
622
 
} // closed Puma
623
 
class CCExprResolve;
624
 
class CExprResolve;
625
 
class WinIfExists;
626
 
class WinImportHandler;
627
 
class WinMacros;
628
 
class WinAsm;
629
 
class WinDeclSpecs;
630
 
class WinMemberExplSpec;
631
 
class WinTypeKeywords;
632
 
class WinFriend;
633
 
class ExtAC;
634
 
class ExtACBuilderCoupling;
635
 
class ExtACSyntaxCoupling;
636
 
class ExtACTree;
637
 
class ExtACKeywords;
638
 
class ExtGnu;
639
 
class PragmaOnceUnitState;
640
 
class PragmaOnce;
641
 
class CMatchSyntax;
642
 
namespace Puma {
643
 
 
644
 
#line 183 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
645
 
class PreElifDirective : public PreTreeComposite
646
 
 {
647
 
#line 648 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
648
 
  friend class ::CCExprResolve;
649
 
  friend class ::CExprResolve;
650
 
  friend class ::WinIfExists;
651
 
  friend class ::WinImportHandler;
652
 
  friend class ::WinMacros;
653
 
  friend class ::WinAsm;
654
 
  friend class ::WinDeclSpecs;
655
 
  friend class ::WinMemberExplSpec;
656
 
  friend class ::WinTypeKeywords;
657
 
  friend class ::WinFriend;
658
 
  friend class ::ExtAC;
659
 
  friend class ::ExtACBuilderCoupling;
660
 
  friend class ::ExtACSyntaxCoupling;
661
 
  friend class ::ExtACTree;
662
 
  friend class ::ExtACKeywords;
663
 
  friend class ::ExtGnu;
664
 
  friend class ::PragmaOnceUnitState;
665
 
  friend class ::PragmaOnce;
666
 
  friend class ::CMatchSyntax;
667
 
 
668
 
#line 184 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
669
 
 
670
 
    public:
671
 
                                        
672
 
        PreElifDirective (PreTree* a, PreTree* b) 
673
 
                        : PreTreeComposite (2, 1) // 2 sons, 1 daughter.
674
 
            { add_son (a); add_son (b); };
675
 
 
676
 
        void accept (PreVisitor& v)
677
 
        {
678
 
            v.visitPreElifDirective_Pre (this);
679
 
            v.iterateNodes (this);
680
 
            v.visitPreElifDirective_Post (this);
681
 
        }
682
 
 };      
683
 
 
684
 
 
685
 
// The #else directive.
686
 
 
687
 
#line 688 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
688
 
} // closed Puma
689
 
class CCExprResolve;
690
 
class CExprResolve;
691
 
class WinIfExists;
692
 
class WinImportHandler;
693
 
class WinMacros;
694
 
class WinAsm;
695
 
class WinDeclSpecs;
696
 
class WinMemberExplSpec;
697
 
class WinTypeKeywords;
698
 
class WinFriend;
699
 
class ExtAC;
700
 
class ExtACBuilderCoupling;
701
 
class ExtACSyntaxCoupling;
702
 
class ExtACTree;
703
 
class ExtACKeywords;
704
 
class ExtGnu;
705
 
class PragmaOnceUnitState;
706
 
class PragmaOnce;
707
 
class CMatchSyntax;
708
 
namespace Puma {
709
 
 
710
 
#line 201 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
711
 
class PreElseDirective : public PreTreeComposite
712
 
 {
713
 
#line 714 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
714
 
  friend class ::CCExprResolve;
715
 
  friend class ::CExprResolve;
716
 
  friend class ::WinIfExists;
717
 
  friend class ::WinImportHandler;
718
 
  friend class ::WinMacros;
719
 
  friend class ::WinAsm;
720
 
  friend class ::WinDeclSpecs;
721
 
  friend class ::WinMemberExplSpec;
722
 
  friend class ::WinTypeKeywords;
723
 
  friend class ::WinFriend;
724
 
  friend class ::ExtAC;
725
 
  friend class ::ExtACBuilderCoupling;
726
 
  friend class ::ExtACSyntaxCoupling;
727
 
  friend class ::ExtACTree;
728
 
  friend class ::ExtACKeywords;
729
 
  friend class ::ExtGnu;
730
 
  friend class ::PragmaOnceUnitState;
731
 
  friend class ::PragmaOnce;
732
 
  friend class ::CMatchSyntax;
733
 
 
734
 
#line 202 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
735
 
 
736
 
    public:
737
 
                                        
738
 
        PreElseDirective (PreTree* a, PreTree* b) 
739
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
740
 
            { add_son (a); add_son (b); };
741
 
 
742
 
        void accept (PreVisitor& v)
743
 
        {
744
 
            v.visitPreElseDirective_Pre (this);
745
 
            v.iterateNodes (this);
746
 
            v.visitPreElseDirective_Post (this);
747
 
        }
748
 
 };      
749
 
 
750
 
 
751
 
// The #endif directive.
752
 
 
753
 
#line 754 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
754
 
} // closed Puma
755
 
class CCExprResolve;
756
 
class CExprResolve;
757
 
class WinIfExists;
758
 
class WinImportHandler;
759
 
class WinMacros;
760
 
class WinAsm;
761
 
class WinDeclSpecs;
762
 
class WinMemberExplSpec;
763
 
class WinTypeKeywords;
764
 
class WinFriend;
765
 
class ExtAC;
766
 
class ExtACBuilderCoupling;
767
 
class ExtACSyntaxCoupling;
768
 
class ExtACTree;
769
 
class ExtACKeywords;
770
 
class ExtGnu;
771
 
class PragmaOnceUnitState;
772
 
class PragmaOnce;
773
 
class CMatchSyntax;
774
 
namespace Puma {
775
 
 
776
 
#line 219 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
777
 
class PreEndifDirective : public PreTreeComposite
778
 
 {
779
 
#line 780 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
780
 
  friend class ::CCExprResolve;
781
 
  friend class ::CExprResolve;
782
 
  friend class ::WinIfExists;
783
 
  friend class ::WinImportHandler;
784
 
  friend class ::WinMacros;
785
 
  friend class ::WinAsm;
786
 
  friend class ::WinDeclSpecs;
787
 
  friend class ::WinMemberExplSpec;
788
 
  friend class ::WinTypeKeywords;
789
 
  friend class ::WinFriend;
790
 
  friend class ::ExtAC;
791
 
  friend class ::ExtACBuilderCoupling;
792
 
  friend class ::ExtACSyntaxCoupling;
793
 
  friend class ::ExtACTree;
794
 
  friend class ::ExtACKeywords;
795
 
  friend class ::ExtGnu;
796
 
  friend class ::PragmaOnceUnitState;
797
 
  friend class ::PragmaOnce;
798
 
  friend class ::CMatchSyntax;
799
 
 
800
 
#line 220 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
801
 
 
802
 
    public:
803
 
                                        
804
 
        PreEndifDirective (PreTree* a, PreTree* b) 
805
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
806
 
            { add_son (a); add_son (b); };
807
 
 
808
 
        void accept (PreVisitor& v)
809
 
        {
810
 
            v.visitPreEndifDirective_Pre (this);
811
 
            v.iterateNodes (this);
812
 
            v.visitPreEndifDirective_Post (this);
813
 
        }
814
 
 };      
815
 
 
816
 
 
817
 
// The #include and #include_next directive.
818
 
 
819
 
#line 820 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
820
 
} // closed Puma
821
 
class CCExprResolve;
822
 
class CExprResolve;
823
 
class WinIfExists;
824
 
class WinImportHandler;
825
 
class WinMacros;
826
 
class WinAsm;
827
 
class WinDeclSpecs;
828
 
class WinMemberExplSpec;
829
 
class WinTypeKeywords;
830
 
class WinFriend;
831
 
class ExtAC;
832
 
class ExtACBuilderCoupling;
833
 
class ExtACSyntaxCoupling;
834
 
class ExtACTree;
835
 
class ExtACKeywords;
836
 
class ExtGnu;
837
 
class PragmaOnceUnitState;
838
 
class PragmaOnce;
839
 
class CMatchSyntax;
840
 
namespace Puma {
841
 
 
842
 
#line 237 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
843
 
class PreIncludeDirective : public PreTreeComposite
844
 
 {
845
 
#line 846 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
846
 
  friend class ::CCExprResolve;
847
 
  friend class ::CExprResolve;
848
 
  friend class ::WinIfExists;
849
 
  friend class ::WinImportHandler;
850
 
  friend class ::WinMacros;
851
 
  friend class ::WinAsm;
852
 
  friend class ::WinDeclSpecs;
853
 
  friend class ::WinMemberExplSpec;
854
 
  friend class ::WinTypeKeywords;
855
 
  friend class ::WinFriend;
856
 
  friend class ::ExtAC;
857
 
  friend class ::ExtACBuilderCoupling;
858
 
  friend class ::ExtACSyntaxCoupling;
859
 
  friend class ::ExtACTree;
860
 
  friend class ::ExtACKeywords;
861
 
  friend class ::ExtGnu;
862
 
  friend class ::PragmaOnceUnitState;
863
 
  friend class ::PragmaOnce;
864
 
  friend class ::CMatchSyntax;
865
 
 
866
 
#line 238 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
867
 
 
868
 
        int _depth;
869
 
 
870
 
    public:
871
 
                                        
872
 
        PreIncludeDirective (PreTree* a, PreTree* b) 
873
 
                        : PreTreeComposite (2, 1) // 2 sons, 1 daughter.
874
 
            { add_son (a); add_son (b); _depth = -1; };
875
 
 
876
 
        void accept (PreVisitor& v)
877
 
        {
878
 
            v.visitPreIncludeDirective_Pre (this);
879
 
            v.iterateNodes (this);
880
 
            v.visitPreIncludeDirective_Post (this);
881
 
        }
882
 
        
883
 
        int depth () const 
884
 
        {
885
 
            return _depth;
886
 
        }
887
 
 
888
 
        void depth (int d)
889
 
        {
890
 
            _depth = d;
891
 
        }
892
 
        
893
 
        bool is_forced () const {
894
 
          return !((Unit*)startToken ()->belonging_to ())->isFile ();
895
 
        }
896
 
 };      
897
 
 
898
 
 
899
 
// The #assert directive.
900
 
 
901
 
#line 902 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
902
 
} // closed Puma
903
 
class CCExprResolve;
904
 
class CExprResolve;
905
 
class WinIfExists;
906
 
class WinImportHandler;
907
 
class WinMacros;
908
 
class WinAsm;
909
 
class WinDeclSpecs;
910
 
class WinMemberExplSpec;
911
 
class WinTypeKeywords;
912
 
class WinFriend;
913
 
class ExtAC;
914
 
class ExtACBuilderCoupling;
915
 
class ExtACSyntaxCoupling;
916
 
class ExtACTree;
917
 
class ExtACKeywords;
918
 
class ExtGnu;
919
 
class PragmaOnceUnitState;
920
 
class PragmaOnce;
921
 
class CMatchSyntax;
922
 
namespace Puma {
923
 
 
924
 
#line 271 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
925
 
class PreAssertDirective : public PreTreeComposite
926
 
 {
927
 
#line 928 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
928
 
  friend class ::CCExprResolve;
929
 
  friend class ::CExprResolve;
930
 
  friend class ::WinIfExists;
931
 
  friend class ::WinImportHandler;
932
 
  friend class ::WinMacros;
933
 
  friend class ::WinAsm;
934
 
  friend class ::WinDeclSpecs;
935
 
  friend class ::WinMemberExplSpec;
936
 
  friend class ::WinTypeKeywords;
937
 
  friend class ::WinFriend;
938
 
  friend class ::ExtAC;
939
 
  friend class ::ExtACBuilderCoupling;
940
 
  friend class ::ExtACSyntaxCoupling;
941
 
  friend class ::ExtACTree;
942
 
  friend class ::ExtACKeywords;
943
 
  friend class ::ExtGnu;
944
 
  friend class ::PragmaOnceUnitState;
945
 
  friend class ::PragmaOnce;
946
 
  friend class ::CMatchSyntax;
947
 
 
948
 
#line 272 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
949
 
 
950
 
    public:
951
 
                                        
952
 
        PreAssertDirective (PreTree* a, PreTree* b, PreTree* c) 
953
 
                        : PreTreeComposite (3, 0) // 3 sons, no daughters.
954
 
            { add_son (a); add_son (b); add_son (c); };
955
 
        PreAssertDirective (PreTree* a, PreTree* b) 
956
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
957
 
            { add_son (a); add_son (b); };
958
 
 
959
 
        void accept (PreVisitor& v)
960
 
        {
961
 
            v.visitPreAssertDirective_Pre (this);
962
 
            v.iterateNodes (this);
963
 
            v.visitPreAssertDirective_Post (this);
964
 
        }
965
 
 };      
966
 
 
967
 
 
968
 
// The #unassert directive.
969
 
 
970
 
#line 971 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
971
 
} // closed Puma
972
 
class CCExprResolve;
973
 
class CExprResolve;
974
 
class WinIfExists;
975
 
class WinImportHandler;
976
 
class WinMacros;
977
 
class WinAsm;
978
 
class WinDeclSpecs;
979
 
class WinMemberExplSpec;
980
 
class WinTypeKeywords;
981
 
class WinFriend;
982
 
class ExtAC;
983
 
class ExtACBuilderCoupling;
984
 
class ExtACSyntaxCoupling;
985
 
class ExtACTree;
986
 
class ExtACKeywords;
987
 
class ExtGnu;
988
 
class PragmaOnceUnitState;
989
 
class PragmaOnce;
990
 
class CMatchSyntax;
991
 
namespace Puma {
992
 
 
993
 
#line 292 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
994
 
class PreUnassertDirective : public PreTreeComposite
995
 
 {
996
 
#line 997 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
997
 
  friend class ::CCExprResolve;
998
 
  friend class ::CExprResolve;
999
 
  friend class ::WinIfExists;
1000
 
  friend class ::WinImportHandler;
1001
 
  friend class ::WinMacros;
1002
 
  friend class ::WinAsm;
1003
 
  friend class ::WinDeclSpecs;
1004
 
  friend class ::WinMemberExplSpec;
1005
 
  friend class ::WinTypeKeywords;
1006
 
  friend class ::WinFriend;
1007
 
  friend class ::ExtAC;
1008
 
  friend class ::ExtACBuilderCoupling;
1009
 
  friend class ::ExtACSyntaxCoupling;
1010
 
  friend class ::ExtACTree;
1011
 
  friend class ::ExtACKeywords;
1012
 
  friend class ::ExtGnu;
1013
 
  friend class ::PragmaOnceUnitState;
1014
 
  friend class ::PragmaOnce;
1015
 
  friend class ::CMatchSyntax;
1016
 
 
1017
 
#line 293 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1018
 
 
1019
 
    public:
1020
 
                                        
1021
 
        PreUnassertDirective (PreTree* a, PreTree* b, PreTree* c) 
1022
 
                        : PreTreeComposite (3, 0) // 3 sons, no daughters.
1023
 
            { add_son (a); add_son (b); add_son (c); };
1024
 
        PreUnassertDirective (PreTree* a, PreTree* b) 
1025
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1026
 
            { add_son (a); add_son (b); };
1027
 
 
1028
 
        void accept (PreVisitor& v)
1029
 
        {
1030
 
            v.visitPreUnassertDirective_Pre (this);
1031
 
            v.iterateNodes (this);
1032
 
            v.visitPreUnassertDirective_Post (this);
1033
 
        }
1034
 
 };      
1035
 
 
1036
 
 
1037
 
// The #define directive that defines function-like macros.
1038
 
// Like: #define FUNCTION (id,...,id) ... ... ...
1039
 
 
1040
 
#line 1041 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1041
 
} // closed Puma
1042
 
class CCExprResolve;
1043
 
class CExprResolve;
1044
 
class WinIfExists;
1045
 
class WinImportHandler;
1046
 
class WinMacros;
1047
 
class WinAsm;
1048
 
class WinDeclSpecs;
1049
 
class WinMemberExplSpec;
1050
 
class WinTypeKeywords;
1051
 
class WinFriend;
1052
 
class ExtAC;
1053
 
class ExtACBuilderCoupling;
1054
 
class ExtACSyntaxCoupling;
1055
 
class ExtACTree;
1056
 
class ExtACKeywords;
1057
 
class ExtGnu;
1058
 
class PragmaOnceUnitState;
1059
 
class PragmaOnce;
1060
 
class CMatchSyntax;
1061
 
namespace Puma {
1062
 
 
1063
 
#line 314 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1064
 
class PreDefineFunctionDirective : public PreTreeComposite
1065
 
 {
1066
 
#line 1067 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1067
 
  friend class ::CCExprResolve;
1068
 
  friend class ::CExprResolve;
1069
 
  friend class ::WinIfExists;
1070
 
  friend class ::WinImportHandler;
1071
 
  friend class ::WinMacros;
1072
 
  friend class ::WinAsm;
1073
 
  friend class ::WinDeclSpecs;
1074
 
  friend class ::WinMemberExplSpec;
1075
 
  friend class ::WinTypeKeywords;
1076
 
  friend class ::WinFriend;
1077
 
  friend class ::ExtAC;
1078
 
  friend class ::ExtACBuilderCoupling;
1079
 
  friend class ::ExtACSyntaxCoupling;
1080
 
  friend class ::ExtACTree;
1081
 
  friend class ::ExtACKeywords;
1082
 
  friend class ::ExtGnu;
1083
 
  friend class ::PragmaOnceUnitState;
1084
 
  friend class ::PragmaOnce;
1085
 
  friend class ::CMatchSyntax;
1086
 
 
1087
 
#line 315 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1088
 
 
1089
 
    public:
1090
 
                                        
1091
 
        PreDefineFunctionDirective (PreTree* a, PreTree* b, 
1092
 
                                    PreTree* c, PreTree* d, 
1093
 
                                    PreTree* e, PreTree* f, 
1094
 
                                    PreTree* g, PreTree* h) 
1095
 
                        : PreTreeComposite (8, 0) // 8 sons, no daughters.
1096
 
            { add_son (a); add_son (b); add_son (c); add_son (d);
1097
 
              add_son (e); add_son (f); add_son (g); add_son (h); }
1098
 
 
1099
 
        PreDefineFunctionDirective (PreTree* a, PreTree* b, 
1100
 
                                    PreTree* c, PreTree* d, 
1101
 
                                    PreTree* e, PreTree* f, 
1102
 
                                    PreTree* g) 
1103
 
                        : PreTreeComposite (7, 0) // 7 sons, no daughters.
1104
 
            { add_son (a); add_son (b); add_son (c); add_son (d);
1105
 
              add_son (e); add_son (f); add_son (g); }
1106
 
 
1107
 
        PreDefineFunctionDirective (PreTree* a, PreTree* b, 
1108
 
                                    PreTree* c, PreTree* d, 
1109
 
                                    PreTree* e, PreTree* f) 
1110
 
                        : PreTreeComposite (6, 0) // 6 sons, no daughters.
1111
 
            { add_son (a); add_son (b); add_son (c); add_son (d);
1112
 
              add_son (e); add_son (f); }
1113
 
        
1114
 
        PreDefineFunctionDirective (PreTree* a, PreTree* b, PreTree* c, 
1115
 
                                   PreTree* d, PreTree* e) 
1116
 
                        : PreTreeComposite (5, 0) // 5 sons, no daughters.
1117
 
            { add_son (a); add_son (b); add_son (c); add_son (d); add_son (e); }
1118
 
 
1119
 
        void accept (PreVisitor& v)
1120
 
        {
1121
 
            v.visitPreDefineFunctionDirective_Pre (this);
1122
 
            v.iterateNodes (this);
1123
 
            v.visitPreDefineFunctionDirective_Post (this);
1124
 
        }
1125
 
 };              
1126
 
 
1127
 
 
1128
 
// The #define directive that defines symbolic constants macros.
1129
 
// Like: #define CONSTANT ... ... ...
1130
 
 
1131
 
#line 1132 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1132
 
} // closed Puma
1133
 
class CCExprResolve;
1134
 
class CExprResolve;
1135
 
class WinIfExists;
1136
 
class WinImportHandler;
1137
 
class WinMacros;
1138
 
class WinAsm;
1139
 
class WinDeclSpecs;
1140
 
class WinMemberExplSpec;
1141
 
class WinTypeKeywords;
1142
 
class WinFriend;
1143
 
class ExtAC;
1144
 
class ExtACBuilderCoupling;
1145
 
class ExtACSyntaxCoupling;
1146
 
class ExtACTree;
1147
 
class ExtACKeywords;
1148
 
class ExtGnu;
1149
 
class PragmaOnceUnitState;
1150
 
class PragmaOnce;
1151
 
class CMatchSyntax;
1152
 
namespace Puma {
1153
 
 
1154
 
#line 357 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1155
 
class PreDefineConstantDirective : public PreTreeComposite
1156
 
 {
1157
 
#line 1158 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1158
 
  friend class ::CCExprResolve;
1159
 
  friend class ::CExprResolve;
1160
 
  friend class ::WinIfExists;
1161
 
  friend class ::WinImportHandler;
1162
 
  friend class ::WinMacros;
1163
 
  friend class ::WinAsm;
1164
 
  friend class ::WinDeclSpecs;
1165
 
  friend class ::WinMemberExplSpec;
1166
 
  friend class ::WinTypeKeywords;
1167
 
  friend class ::WinFriend;
1168
 
  friend class ::ExtAC;
1169
 
  friend class ::ExtACBuilderCoupling;
1170
 
  friend class ::ExtACSyntaxCoupling;
1171
 
  friend class ::ExtACTree;
1172
 
  friend class ::ExtACKeywords;
1173
 
  friend class ::ExtGnu;
1174
 
  friend class ::PragmaOnceUnitState;
1175
 
  friend class ::PragmaOnce;
1176
 
  friend class ::CMatchSyntax;
1177
 
 
1178
 
#line 358 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1179
 
 
1180
 
    public:
1181
 
                                        
1182
 
        PreDefineConstantDirective (PreTree* a, PreTree* b, PreTree* c) 
1183
 
                        : PreTreeComposite (3, 0) // 3 sons, no daughters.
1184
 
            { add_son (a); add_son (b); add_son (c); };
1185
 
        PreDefineConstantDirective (PreTree* a, PreTree* b) 
1186
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1187
 
            { add_son (a); add_son (b); };
1188
 
 
1189
 
        void accept (PreVisitor& v)
1190
 
        {
1191
 
            v.visitPreDefineConstantDirective_Pre (this);
1192
 
            v.iterateNodes (this);
1193
 
            v.visitPreDefineConstantDirective_Post (this);
1194
 
        }
1195
 
 };      
1196
 
 
1197
 
 
1198
 
// The #undef directive.
1199
 
 
1200
 
#line 1201 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1201
 
} // closed Puma
1202
 
class CCExprResolve;
1203
 
class CExprResolve;
1204
 
class WinIfExists;
1205
 
class WinImportHandler;
1206
 
class WinMacros;
1207
 
class WinAsm;
1208
 
class WinDeclSpecs;
1209
 
class WinMemberExplSpec;
1210
 
class WinTypeKeywords;
1211
 
class WinFriend;
1212
 
class ExtAC;
1213
 
class ExtACBuilderCoupling;
1214
 
class ExtACSyntaxCoupling;
1215
 
class ExtACTree;
1216
 
class ExtACKeywords;
1217
 
class ExtGnu;
1218
 
class PragmaOnceUnitState;
1219
 
class PragmaOnce;
1220
 
class CMatchSyntax;
1221
 
namespace Puma {
1222
 
 
1223
 
#line 378 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1224
 
class PreUndefDirective : public PreTreeComposite
1225
 
 {
1226
 
#line 1227 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1227
 
  friend class ::CCExprResolve;
1228
 
  friend class ::CExprResolve;
1229
 
  friend class ::WinIfExists;
1230
 
  friend class ::WinImportHandler;
1231
 
  friend class ::WinMacros;
1232
 
  friend class ::WinAsm;
1233
 
  friend class ::WinDeclSpecs;
1234
 
  friend class ::WinMemberExplSpec;
1235
 
  friend class ::WinTypeKeywords;
1236
 
  friend class ::WinFriend;
1237
 
  friend class ::ExtAC;
1238
 
  friend class ::ExtACBuilderCoupling;
1239
 
  friend class ::ExtACSyntaxCoupling;
1240
 
  friend class ::ExtACTree;
1241
 
  friend class ::ExtACKeywords;
1242
 
  friend class ::ExtGnu;
1243
 
  friend class ::PragmaOnceUnitState;
1244
 
  friend class ::PragmaOnce;
1245
 
  friend class ::CMatchSyntax;
1246
 
 
1247
 
#line 379 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1248
 
 
1249
 
    public:
1250
 
                                        
1251
 
        PreUndefDirective (PreTree* a, PreTree* b, PreTree* c) 
1252
 
                        : PreTreeComposite (3, 0) // 3 sons, no daughters.
1253
 
            { add_son (a); add_son (b); add_son (c); };
1254
 
        PreUndefDirective (PreTree* a, PreTree* b) 
1255
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1256
 
            { add_son (a); add_son (b); };
1257
 
 
1258
 
        void accept (PreVisitor& v)
1259
 
        {
1260
 
            v.visitPreUndefDirective_Pre (this);
1261
 
            v.iterateNodes (this);
1262
 
            v.visitPreUndefDirective_Post (this);
1263
 
        }
1264
 
 };      
1265
 
 
1266
 
 
1267
 
// The #warning directive.
1268
 
 
1269
 
#line 1270 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1270
 
} // closed Puma
1271
 
class CCExprResolve;
1272
 
class CExprResolve;
1273
 
class WinIfExists;
1274
 
class WinImportHandler;
1275
 
class WinMacros;
1276
 
class WinAsm;
1277
 
class WinDeclSpecs;
1278
 
class WinMemberExplSpec;
1279
 
class WinTypeKeywords;
1280
 
class WinFriend;
1281
 
class ExtAC;
1282
 
class ExtACBuilderCoupling;
1283
 
class ExtACSyntaxCoupling;
1284
 
class ExtACTree;
1285
 
class ExtACKeywords;
1286
 
class ExtGnu;
1287
 
class PragmaOnceUnitState;
1288
 
class PragmaOnce;
1289
 
class CMatchSyntax;
1290
 
namespace Puma {
1291
 
 
1292
 
#line 399 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1293
 
class PreWarningDirective : public PreTreeComposite
1294
 
 {
1295
 
#line 1296 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1296
 
  friend class ::CCExprResolve;
1297
 
  friend class ::CExprResolve;
1298
 
  friend class ::WinIfExists;
1299
 
  friend class ::WinImportHandler;
1300
 
  friend class ::WinMacros;
1301
 
  friend class ::WinAsm;
1302
 
  friend class ::WinDeclSpecs;
1303
 
  friend class ::WinMemberExplSpec;
1304
 
  friend class ::WinTypeKeywords;
1305
 
  friend class ::WinFriend;
1306
 
  friend class ::ExtAC;
1307
 
  friend class ::ExtACBuilderCoupling;
1308
 
  friend class ::ExtACSyntaxCoupling;
1309
 
  friend class ::ExtACTree;
1310
 
  friend class ::ExtACKeywords;
1311
 
  friend class ::ExtGnu;
1312
 
  friend class ::PragmaOnceUnitState;
1313
 
  friend class ::PragmaOnce;
1314
 
  friend class ::CMatchSyntax;
1315
 
 
1316
 
#line 400 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1317
 
 
1318
 
    public:
1319
 
                                        
1320
 
        PreWarningDirective (PreTree* a, PreTree* b) 
1321
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1322
 
            { add_son (a); add_son (b); };
1323
 
 
1324
 
        void accept (PreVisitor& v)
1325
 
        {
1326
 
            v.visitPreWarningDirective_Pre (this);
1327
 
            v.iterateNodes (this);
1328
 
            v.visitPreWarningDirective_Post (this);
1329
 
        }
1330
 
 };      
1331
 
 
1332
 
 
1333
 
// The #error directive.
1334
 
 
1335
 
#line 1336 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1336
 
} // closed Puma
1337
 
class CCExprResolve;
1338
 
class CExprResolve;
1339
 
class WinIfExists;
1340
 
class WinImportHandler;
1341
 
class WinMacros;
1342
 
class WinAsm;
1343
 
class WinDeclSpecs;
1344
 
class WinMemberExplSpec;
1345
 
class WinTypeKeywords;
1346
 
class WinFriend;
1347
 
class ExtAC;
1348
 
class ExtACBuilderCoupling;
1349
 
class ExtACSyntaxCoupling;
1350
 
class ExtACTree;
1351
 
class ExtACKeywords;
1352
 
class ExtGnu;
1353
 
class PragmaOnceUnitState;
1354
 
class PragmaOnce;
1355
 
class CMatchSyntax;
1356
 
namespace Puma {
1357
 
 
1358
 
#line 417 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1359
 
class PreErrorDirective : public PreTreeComposite
1360
 
 {
1361
 
#line 1362 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1362
 
  friend class ::CCExprResolve;
1363
 
  friend class ::CExprResolve;
1364
 
  friend class ::WinIfExists;
1365
 
  friend class ::WinImportHandler;
1366
 
  friend class ::WinMacros;
1367
 
  friend class ::WinAsm;
1368
 
  friend class ::WinDeclSpecs;
1369
 
  friend class ::WinMemberExplSpec;
1370
 
  friend class ::WinTypeKeywords;
1371
 
  friend class ::WinFriend;
1372
 
  friend class ::ExtAC;
1373
 
  friend class ::ExtACBuilderCoupling;
1374
 
  friend class ::ExtACSyntaxCoupling;
1375
 
  friend class ::ExtACTree;
1376
 
  friend class ::ExtACKeywords;
1377
 
  friend class ::ExtGnu;
1378
 
  friend class ::PragmaOnceUnitState;
1379
 
  friend class ::PragmaOnce;
1380
 
  friend class ::CMatchSyntax;
1381
 
 
1382
 
#line 418 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1383
 
 
1384
 
    public:
1385
 
                                        
1386
 
        PreErrorDirective (PreTree* a, PreTree* b) 
1387
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1388
 
            { add_son (a); add_son (b); };
1389
 
 
1390
 
        void accept (PreVisitor& v)
1391
 
        {
1392
 
            v.visitPreErrorDirective_Pre (this);
1393
 
            v.iterateNodes (this);
1394
 
            v.visitPreErrorDirective_Post (this);
1395
 
        }
1396
 
 };      
1397
 
 
1398
 
 
1399
 
// Collects comma separated argument identifiers for a function-like macro.
1400
 
// Like: id, id, ..., id.
1401
 
 
1402
 
#line 1403 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1403
 
} // closed Puma
1404
 
class CCExprResolve;
1405
 
class CExprResolve;
1406
 
class WinIfExists;
1407
 
class WinImportHandler;
1408
 
class WinMacros;
1409
 
class WinAsm;
1410
 
class WinDeclSpecs;
1411
 
class WinMemberExplSpec;
1412
 
class WinTypeKeywords;
1413
 
class WinFriend;
1414
 
class ExtAC;
1415
 
class ExtACBuilderCoupling;
1416
 
class ExtACSyntaxCoupling;
1417
 
class ExtACTree;
1418
 
class ExtACKeywords;
1419
 
class ExtGnu;
1420
 
class PragmaOnceUnitState;
1421
 
class PragmaOnce;
1422
 
class CMatchSyntax;
1423
 
namespace Puma {
1424
 
 
1425
 
#line 436 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1426
 
class PreIdentifierList : public PreTreeComposite
1427
 
 {
1428
 
#line 1429 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1429
 
  friend class ::CCExprResolve;
1430
 
  friend class ::CExprResolve;
1431
 
  friend class ::WinIfExists;
1432
 
  friend class ::WinImportHandler;
1433
 
  friend class ::WinMacros;
1434
 
  friend class ::WinAsm;
1435
 
  friend class ::WinDeclSpecs;
1436
 
  friend class ::WinMemberExplSpec;
1437
 
  friend class ::WinTypeKeywords;
1438
 
  friend class ::WinFriend;
1439
 
  friend class ::ExtAC;
1440
 
  friend class ::ExtACBuilderCoupling;
1441
 
  friend class ::ExtACSyntaxCoupling;
1442
 
  friend class ::ExtACTree;
1443
 
  friend class ::ExtACKeywords;
1444
 
  friend class ::ExtGnu;
1445
 
  friend class ::PragmaOnceUnitState;
1446
 
  friend class ::PragmaOnce;
1447
 
  friend class ::CMatchSyntax;
1448
 
 
1449
 
#line 437 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1450
 
 
1451
 
    public:
1452
 
                                        // Dynamic sons, no daughters. 
1453
 
        PreIdentifierList (PreTree* a) : PreTreeComposite (-1, 0)
1454
 
            { add_son (a); };
1455
 
        
1456
 
        // Add two sons.
1457
 
        void addSons (PreTree* a, PreTree* b)
1458
 
            { add_son (a); add_son (b); };
1459
 
 
1460
 
        void accept (PreVisitor& v)
1461
 
        {
1462
 
            v.visitPreIdentifierList_Pre (this);
1463
 
            v.iterateNodes (this);
1464
 
            v.visitPreIdentifierList_Post (this);
1465
 
        }
1466
 
 };      
1467
 
 
1468
 
 
1469
 
// Collects every kind of token  (except comments) for the macro body.
1470
 
 
1471
 
#line 1472 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1472
 
} // closed Puma
1473
 
class CCExprResolve;
1474
 
class CExprResolve;
1475
 
class WinIfExists;
1476
 
class WinImportHandler;
1477
 
class WinMacros;
1478
 
class WinAsm;
1479
 
class WinDeclSpecs;
1480
 
class WinMemberExplSpec;
1481
 
class WinTypeKeywords;
1482
 
class WinFriend;
1483
 
class ExtAC;
1484
 
class ExtACBuilderCoupling;
1485
 
class ExtACSyntaxCoupling;
1486
 
class ExtACTree;
1487
 
class ExtACKeywords;
1488
 
class ExtGnu;
1489
 
class PragmaOnceUnitState;
1490
 
class PragmaOnce;
1491
 
class CMatchSyntax;
1492
 
namespace Puma {
1493
 
 
1494
 
#line 457 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1495
 
class PreTokenList : public PreTreeComposite
1496
 
 {
1497
 
#line 1498 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1498
 
  friend class ::CCExprResolve;
1499
 
  friend class ::CExprResolve;
1500
 
  friend class ::WinIfExists;
1501
 
  friend class ::WinImportHandler;
1502
 
  friend class ::WinMacros;
1503
 
  friend class ::WinAsm;
1504
 
  friend class ::WinDeclSpecs;
1505
 
  friend class ::WinMemberExplSpec;
1506
 
  friend class ::WinTypeKeywords;
1507
 
  friend class ::WinFriend;
1508
 
  friend class ::ExtAC;
1509
 
  friend class ::ExtACBuilderCoupling;
1510
 
  friend class ::ExtACSyntaxCoupling;
1511
 
  friend class ::ExtACTree;
1512
 
  friend class ::ExtACKeywords;
1513
 
  friend class ::ExtGnu;
1514
 
  friend class ::PragmaOnceUnitState;
1515
 
  friend class ::PragmaOnce;
1516
 
  friend class ::CMatchSyntax;
1517
 
 
1518
 
#line 458 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1519
 
 
1520
 
    public:
1521
 
                                        
1522
 
        PreTokenList (PreTree* a, PreTree* b) 
1523
 
                        : PreTreeComposite (2, 0) // 2 sons, no daughters.
1524
 
            { add_son (a); add_son (b); };
1525
 
        PreTokenList (PreTree* a) 
1526
 
                        : PreTreeComposite (1, 0) // 1 son, no daughters.
1527
 
            { add_son (a); };
1528
 
        PreTokenList () : PreTreeComposite (0, 0) // no sons, no daughters.
1529
 
            { };
1530
 
        
1531
 
        void accept (PreVisitor& v)
1532
 
        {
1533
 
            v.visitPreTokenList_Pre (this);
1534
 
            v.iterateNodes (this);
1535
 
            v.visitPreTokenList_Post (this);
1536
 
        }
1537
 
 };      
1538
 
 
1539
 
 
1540
 
// Contains every kind of token  (except comments) for the macro body.
1541
 
 
1542
 
#line 1543 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1543
 
} // closed Puma
1544
 
class CCExprResolve;
1545
 
class CExprResolve;
1546
 
class WinIfExists;
1547
 
class WinImportHandler;
1548
 
class WinMacros;
1549
 
class WinAsm;
1550
 
class WinDeclSpecs;
1551
 
class WinMemberExplSpec;
1552
 
class WinTypeKeywords;
1553
 
class WinFriend;
1554
 
class ExtAC;
1555
 
class ExtACBuilderCoupling;
1556
 
class ExtACSyntaxCoupling;
1557
 
class ExtACTree;
1558
 
class ExtACKeywords;
1559
 
class ExtGnu;
1560
 
class PragmaOnceUnitState;
1561
 
class PragmaOnce;
1562
 
class CMatchSyntax;
1563
 
namespace Puma {
1564
 
 
1565
 
#line 480 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1566
 
class PreTokenListPart : public PreTreeComposite
1567
 
 {
1568
 
#line 1569 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1569
 
  friend class ::CCExprResolve;
1570
 
  friend class ::CExprResolve;
1571
 
  friend class ::WinIfExists;
1572
 
  friend class ::WinImportHandler;
1573
 
  friend class ::WinMacros;
1574
 
  friend class ::WinAsm;
1575
 
  friend class ::WinDeclSpecs;
1576
 
  friend class ::WinMemberExplSpec;
1577
 
  friend class ::WinTypeKeywords;
1578
 
  friend class ::WinFriend;
1579
 
  friend class ::ExtAC;
1580
 
  friend class ::ExtACBuilderCoupling;
1581
 
  friend class ::ExtACSyntaxCoupling;
1582
 
  friend class ::ExtACTree;
1583
 
  friend class ::ExtACKeywords;
1584
 
  friend class ::ExtGnu;
1585
 
  friend class ::PragmaOnceUnitState;
1586
 
  friend class ::PragmaOnce;
1587
 
  friend class ::CMatchSyntax;
1588
 
 
1589
 
#line 481 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1590
 
 
1591
 
    public:
1592
 
                                        // Dynamic sons, no daughters.
1593
 
        PreTokenListPart (PreTree* a) : PreTreeComposite (-1, 0)
1594
 
            { add_son (a); };
1595
 
        
1596
 
        void accept (PreVisitor& v)
1597
 
        {
1598
 
            v.visitPreTokenListPart_Pre (this);
1599
 
            v.iterateNodes (this);
1600
 
            v.visitPreTokenListPart_Post (this);
1601
 
        }
1602
 
 };      
1603
 
 
1604
 
 
1605
 
// Semantic node for conditionals.
1606
 
 
1607
 
#line 1608 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1608
 
} // closed Puma
1609
 
class CCExprResolve;
1610
 
class CExprResolve;
1611
 
class WinIfExists;
1612
 
class WinImportHandler;
1613
 
class WinMacros;
1614
 
class WinAsm;
1615
 
class WinDeclSpecs;
1616
 
class WinMemberExplSpec;
1617
 
class WinTypeKeywords;
1618
 
class WinFriend;
1619
 
class ExtAC;
1620
 
class ExtACBuilderCoupling;
1621
 
class ExtACSyntaxCoupling;
1622
 
class ExtACTree;
1623
 
class ExtACKeywords;
1624
 
class ExtGnu;
1625
 
class PragmaOnceUnitState;
1626
 
class PragmaOnce;
1627
 
class CMatchSyntax;
1628
 
namespace Puma {
1629
 
 
1630
 
#line 497 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1631
 
class PreCondSemNode : public PreTree
1632
 
 {
1633
 
#line 1634 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1634
 
  friend class ::CCExprResolve;
1635
 
  friend class ::CExprResolve;
1636
 
  friend class ::WinIfExists;
1637
 
  friend class ::WinImportHandler;
1638
 
  friend class ::WinMacros;
1639
 
  friend class ::WinAsm;
1640
 
  friend class ::WinDeclSpecs;
1641
 
  friend class ::WinMemberExplSpec;
1642
 
  friend class ::WinTypeKeywords;
1643
 
  friend class ::WinFriend;
1644
 
  friend class ::ExtAC;
1645
 
  friend class ::ExtACBuilderCoupling;
1646
 
  friend class ::ExtACSyntaxCoupling;
1647
 
  friend class ::ExtACTree;
1648
 
  friend class ::ExtACKeywords;
1649
 
  friend class ::ExtGnu;
1650
 
  friend class ::PragmaOnceUnitState;
1651
 
  friend class ::PragmaOnce;
1652
 
  friend class ::CMatchSyntax;
1653
 
 
1654
 
#line 498 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1655
 
 
1656
 
        // Boolean value of the condition of a conditional.
1657
 
        bool _value;
1658
 
 
1659
 
    public:
1660
 
 
1661
 
        PreCondSemNode (bool value) : _value (value) {};
1662
 
        
1663
 
        void accept (PreVisitor& v)
1664
 
        {
1665
 
            v.visitPreCondSemNode (this);
1666
 
        }
1667
 
        
1668
 
        // Get the value of the conditional.
1669
 
        bool value () const { return _value; }
1670
 
 };      
1671
 
 
1672
 
 
1673
 
// Semantic node for the #include directive.
1674
 
 
1675
 
#line 1676 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1676
 
} // closed Puma
1677
 
class CCExprResolve;
1678
 
class CExprResolve;
1679
 
class WinIfExists;
1680
 
class WinImportHandler;
1681
 
class WinMacros;
1682
 
class WinAsm;
1683
 
class WinDeclSpecs;
1684
 
class WinMemberExplSpec;
1685
 
class WinTypeKeywords;
1686
 
class WinFriend;
1687
 
class ExtAC;
1688
 
class ExtACBuilderCoupling;
1689
 
class ExtACSyntaxCoupling;
1690
 
class ExtACTree;
1691
 
class ExtACKeywords;
1692
 
class ExtGnu;
1693
 
class PragmaOnceUnitState;
1694
 
class PragmaOnce;
1695
 
class CMatchSyntax;
1696
 
namespace Puma {
1697
 
 
1698
 
#line 517 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1699
 
class PreInclSemNode : public PreTree
1700
 
 {
1701
 
#line 1702 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1702
 
  friend class ::CCExprResolve;
1703
 
  friend class ::CExprResolve;
1704
 
  friend class ::WinIfExists;
1705
 
  friend class ::WinImportHandler;
1706
 
  friend class ::WinMacros;
1707
 
  friend class ::WinAsm;
1708
 
  friend class ::WinDeclSpecs;
1709
 
  friend class ::WinMemberExplSpec;
1710
 
  friend class ::WinTypeKeywords;
1711
 
  friend class ::WinFriend;
1712
 
  friend class ::ExtAC;
1713
 
  friend class ::ExtACBuilderCoupling;
1714
 
  friend class ::ExtACSyntaxCoupling;
1715
 
  friend class ::ExtACTree;
1716
 
  friend class ::ExtACKeywords;
1717
 
  friend class ::ExtGnu;
1718
 
  friend class ::PragmaOnceUnitState;
1719
 
  friend class ::PragmaOnce;
1720
 
  friend class ::CMatchSyntax;
1721
 
 
1722
 
#line 518 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1723
 
 
1724
 
        // Pointer of the included file unit.
1725
 
        Unit* _unit;
1726
 
        
1727
 
        // true if the inclusion was not done, because of an active include
1728
 
        // guard
1729
 
        bool _guarded;
1730
 
 
1731
 
    public:
1732
 
 
1733
 
        PreInclSemNode (Unit* unit, bool guarded) :
1734
 
          _unit (unit), _guarded (guarded) {};
1735
 
        
1736
 
        void accept (PreVisitor& v)
1737
 
        {
1738
 
            v.visitPreInclSemNode (this);
1739
 
        }
1740
 
        
1741
 
        // Get the included file unit.
1742
 
        Unit* unit () const { return _unit; }
1743
 
        
1744
 
        // Check if the inclusion was not done, because of an include guard
1745
 
        bool guarded () const { return _guarded; }
1746
 
 };      
1747
 
 
1748
 
 
1749
 
// Special parse error node to show the location of an error in the
1750
 
// preprocessor syntax tree.
1751
 
 
1752
 
#line 1753 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1753
 
} // closed Puma
1754
 
class CCExprResolve;
1755
 
class CExprResolve;
1756
 
class WinIfExists;
1757
 
class WinImportHandler;
1758
 
class WinMacros;
1759
 
class WinAsm;
1760
 
class WinDeclSpecs;
1761
 
class WinMemberExplSpec;
1762
 
class WinTypeKeywords;
1763
 
class WinFriend;
1764
 
class ExtAC;
1765
 
class ExtACBuilderCoupling;
1766
 
class ExtACSyntaxCoupling;
1767
 
class ExtACTree;
1768
 
class ExtACKeywords;
1769
 
class ExtGnu;
1770
 
class PragmaOnceUnitState;
1771
 
class PragmaOnce;
1772
 
class CMatchSyntax;
1773
 
namespace Puma {
1774
 
 
1775
 
#line 546 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1776
 
class PreError : public PreTree
1777
 
 {
1778
 
#line 1779 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1779
 
  friend class ::CCExprResolve;
1780
 
  friend class ::CExprResolve;
1781
 
  friend class ::WinIfExists;
1782
 
  friend class ::WinImportHandler;
1783
 
  friend class ::WinMacros;
1784
 
  friend class ::WinAsm;
1785
 
  friend class ::WinDeclSpecs;
1786
 
  friend class ::WinMemberExplSpec;
1787
 
  friend class ::WinTypeKeywords;
1788
 
  friend class ::WinFriend;
1789
 
  friend class ::ExtAC;
1790
 
  friend class ::ExtACBuilderCoupling;
1791
 
  friend class ::ExtACSyntaxCoupling;
1792
 
  friend class ::ExtACTree;
1793
 
  friend class ::ExtACKeywords;
1794
 
  friend class ::ExtGnu;
1795
 
  friend class ::PragmaOnceUnitState;
1796
 
  friend class ::PragmaOnce;
1797
 
  friend class ::CMatchSyntax;
1798
 
 
1799
 
#line 547 "/var/tmp/aspectc++/debian/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
1800
 
 
1801
 
    public:
1802
 
 
1803
 
        PreError () {};
1804
 
        
1805
 
        void accept (PreVisitor& v)
1806
 
        {
1807
 
            v.visitPreError (this);
1808
 
        }
1809
 
 };      
 
416
public:
 
417
  typedef AC::TLE __AttrTypes;
 
418
  const char *__attr_name (unsigned i) const { return 0; }
 
419
  const void *__attr (unsigned __i) const { return 0; }
 
420
#line 135 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
421
};      
 
422
 
 
423
 
 
424
/** \class PreElifPart PreTreeNodes.h Puma/PreTreeNodes.h
 
425
 *  Preprocessor tree node representing a group of directives 
 
426
 *  in the \#elif part of an \#if conditional. */
 
427
 
 
428
#line 429 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
429
} // closed Puma
 
430
class CCExprResolve;
 
431
class CExprResolve;
 
432
class WinIfExists;
 
433
class WinImportHandler;
 
434
class WinMacros;
 
435
class WinAsm;
 
436
class WinDeclSpecs;
 
437
class WinMemberExplSpec;
 
438
class WinTypeKeywords;
 
439
class WinFriend;
 
440
class ExtAC;
 
441
class ExtACBuilderCoupling;
 
442
class ExtACSyntaxCoupling;
 
443
class ExtACTree;
 
444
class ExtACKeywords;
 
445
class ExtGnu;
 
446
class PragmaOnceUnitState;
 
447
class PragmaOnce;
 
448
class CMatchSyntax;
 
449
namespace Puma {
 
450
 
 
451
#line 141 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
452
class PreElifPart : public PreTreeComposite {
 
453
#line 454 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
454
  friend class ::CCExprResolve;
 
455
  friend class ::CExprResolve;
 
456
  friend class ::WinIfExists;
 
457
  friend class ::WinImportHandler;
 
458
  friend class ::WinMacros;
 
459
  friend class ::WinAsm;
 
460
  friend class ::WinDeclSpecs;
 
461
  friend class ::WinMemberExplSpec;
 
462
  friend class ::WinTypeKeywords;
 
463
  friend class ::WinFriend;
 
464
  friend class ::ExtAC;
 
465
  friend class ::ExtACBuilderCoupling;
 
466
  friend class ::ExtACSyntaxCoupling;
 
467
  friend class ::ExtACTree;
 
468
  friend class ::ExtACKeywords;
 
469
  friend class ::ExtGnu;
 
470
  friend class ::PragmaOnceUnitState;
 
471
  friend class ::PragmaOnce;
 
472
  friend class ::CMatchSyntax;
 
473
 
 
474
#line 141 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
475
 
 
476
public:
 
477
  /** Constructor. */
 
478
  PreElifPart () : PreTreeComposite (-1, 0) {}
 
479
        
 
480
  /** Add two sons, a directive group and a \#elif directive.
 
481
   *  \param dg The directive group.
 
482
   *  \param el The \#elif directive. */
 
483
  void addSons (PreTree* dg, PreTree* el) { 
 
484
    add_son (dg); add_son (el); 
 
485
  }
 
486
 
 
487
  /** Part of the tree visitor pattern. Calls the node
 
488
   *  visiting functions suitable for this node type. 
 
489
   *  \param v The visitor object on which to call the 
 
490
   *           visiting functions. */
 
491
  void accept (PreVisitor& v) {
 
492
    v.visitPreElifPart_Pre (this);
 
493
    v.iterateNodes (this);
 
494
    v.visitPreElifPart_Post (this);
 
495
  }
 
496
public:
 
497
  typedef AC::TLE __AttrTypes;
 
498
  const char *__attr_name (unsigned i) const { return 0; }
 
499
  const void *__attr (unsigned __i) const { return 0; }
 
500
#line 162 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
501
};      
 
502
 
 
503
 
 
504
/** \class PreIfDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
505
 *  Preprocessor tree node representing an \#if directive. 
 
506
 *  Example: \code #if OSTYPE==Linux \endcode */
 
507
 
 
508
#line 509 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
509
} // closed Puma
 
510
class CCExprResolve;
 
511
class CExprResolve;
 
512
class WinIfExists;
 
513
class WinImportHandler;
 
514
class WinMacros;
 
515
class WinAsm;
 
516
class WinDeclSpecs;
 
517
class WinMemberExplSpec;
 
518
class WinTypeKeywords;
 
519
class WinFriend;
 
520
class ExtAC;
 
521
class ExtACBuilderCoupling;
 
522
class ExtACSyntaxCoupling;
 
523
class ExtACTree;
 
524
class ExtACKeywords;
 
525
class ExtGnu;
 
526
class PragmaOnceUnitState;
 
527
class PragmaOnce;
 
528
class CMatchSyntax;
 
529
namespace Puma {
 
530
 
 
531
#line 168 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
532
class PreIfDirective : public PreTreeComposite {
 
533
#line 534 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
534
  friend class ::CCExprResolve;
 
535
  friend class ::CExprResolve;
 
536
  friend class ::WinIfExists;
 
537
  friend class ::WinImportHandler;
 
538
  friend class ::WinMacros;
 
539
  friend class ::WinAsm;
 
540
  friend class ::WinDeclSpecs;
 
541
  friend class ::WinMemberExplSpec;
 
542
  friend class ::WinTypeKeywords;
 
543
  friend class ::WinFriend;
 
544
  friend class ::ExtAC;
 
545
  friend class ::ExtACBuilderCoupling;
 
546
  friend class ::ExtACSyntaxCoupling;
 
547
  friend class ::ExtACTree;
 
548
  friend class ::ExtACKeywords;
 
549
  friend class ::ExtGnu;
 
550
  friend class ::PragmaOnceUnitState;
 
551
  friend class ::PragmaOnce;
 
552
  friend class ::CMatchSyntax;
 
553
 
 
554
#line 168 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
555
 
 
556
public:
 
557
  /** Constructor.
 
558
   *  \param i The \#if token.
 
559
   *  \param c The condition. */
 
560
  PreIfDirective (PreTree* i, PreTree* c) : PreTreeComposite (2, 1) { 
 
561
    add_son (i); add_son (c); 
 
562
  }
 
563
 
 
564
  /** Part of the tree visitor pattern. Calls the node
 
565
   *  visiting functions suitable for this node type. 
 
566
   *  \param v The visitor object on which to call the 
 
567
   *           visiting functions. */
 
568
  void accept (PreVisitor& v) {
 
569
    v.visitPreIfDirective_Pre (this);
 
570
    v.iterateNodes (this);
 
571
    v.visitPreIfDirective_Post (this);
 
572
  }
 
573
public:
 
574
  typedef AC::TLE __AttrTypes;
 
575
  const char *__attr_name (unsigned i) const { return 0; }
 
576
  const void *__attr (unsigned __i) const { return 0; }
 
577
#line 186 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
578
};      
 
579
 
 
580
 
 
581
/** \class PreIfdefDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
582
 *  Preprocessor tree node representing an \#ifdef directive. 
 
583
 *  Example: \code #ifdef Linux \endcode */
 
584
 
 
585
#line 586 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
586
} // closed Puma
 
587
class CCExprResolve;
 
588
class CExprResolve;
 
589
class WinIfExists;
 
590
class WinImportHandler;
 
591
class WinMacros;
 
592
class WinAsm;
 
593
class WinDeclSpecs;
 
594
class WinMemberExplSpec;
 
595
class WinTypeKeywords;
 
596
class WinFriend;
 
597
class ExtAC;
 
598
class ExtACBuilderCoupling;
 
599
class ExtACSyntaxCoupling;
 
600
class ExtACTree;
 
601
class ExtACKeywords;
 
602
class ExtGnu;
 
603
class PragmaOnceUnitState;
 
604
class PragmaOnce;
 
605
class CMatchSyntax;
 
606
namespace Puma {
 
607
 
 
608
#line 192 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
609
class PreIfdefDirective : public PreTreeComposite {
 
610
#line 611 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
611
  friend class ::CCExprResolve;
 
612
  friend class ::CExprResolve;
 
613
  friend class ::WinIfExists;
 
614
  friend class ::WinImportHandler;
 
615
  friend class ::WinMacros;
 
616
  friend class ::WinAsm;
 
617
  friend class ::WinDeclSpecs;
 
618
  friend class ::WinMemberExplSpec;
 
619
  friend class ::WinTypeKeywords;
 
620
  friend class ::WinFriend;
 
621
  friend class ::ExtAC;
 
622
  friend class ::ExtACBuilderCoupling;
 
623
  friend class ::ExtACSyntaxCoupling;
 
624
  friend class ::ExtACTree;
 
625
  friend class ::ExtACKeywords;
 
626
  friend class ::ExtGnu;
 
627
  friend class ::PragmaOnceUnitState;
 
628
  friend class ::PragmaOnce;
 
629
  friend class ::CMatchSyntax;
 
630
 
 
631
#line 192 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
632
 
 
633
public:
 
634
  /** Constructor. 
 
635
   *  \param i The \#ifdef token.
 
636
   *  \param n The name of the macro. 
 
637
   *  \param tl The remaining tokens of the line. */
 
638
  PreIfdefDirective (PreTree* i, PreTree* n, PreTree* tl) : PreTreeComposite (3, 1) { 
 
639
    add_son (i); add_son (n); add_son (tl); 
 
640
  }
 
641
  /** Constructor. 
 
642
   *  \param i The \#ifdef token.
 
643
   *  \param tl The remaining tokens of the line. */
 
644
  PreIfdefDirective (PreTree* i, PreTree* tl) : PreTreeComposite (2, 0) { 
 
645
    add_son (i); add_son (tl); 
 
646
  }
 
647
 
 
648
  /** Part of the tree visitor pattern. Calls the node
 
649
   *  visiting functions suitable for this node type. 
 
650
   *  \param v The visitor object on which to call the 
 
651
   *           visiting functions. */
 
652
  void accept (PreVisitor& v) {
 
653
    v.visitPreIfdefDirective_Pre (this);
 
654
    v.iterateNodes (this);
 
655
    v.visitPreIfdefDirective_Post (this);
 
656
  }
 
657
public:
 
658
  typedef AC::TLE __AttrTypes;
 
659
  const char *__attr_name (unsigned i) const { return 0; }
 
660
  const void *__attr (unsigned __i) const { return 0; }
 
661
#line 217 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
662
};      
 
663
 
 
664
 
 
665
/** \class PreIfndefDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
666
 *  Preprocessor tree node representing an \#ifndef directive. 
 
667
 *  Example: \code #ifndef Linux \endcode */
 
668
 
 
669
#line 670 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
670
} // closed Puma
 
671
class CCExprResolve;
 
672
class CExprResolve;
 
673
class WinIfExists;
 
674
class WinImportHandler;
 
675
class WinMacros;
 
676
class WinAsm;
 
677
class WinDeclSpecs;
 
678
class WinMemberExplSpec;
 
679
class WinTypeKeywords;
 
680
class WinFriend;
 
681
class ExtAC;
 
682
class ExtACBuilderCoupling;
 
683
class ExtACSyntaxCoupling;
 
684
class ExtACTree;
 
685
class ExtACKeywords;
 
686
class ExtGnu;
 
687
class PragmaOnceUnitState;
 
688
class PragmaOnce;
 
689
class CMatchSyntax;
 
690
namespace Puma {
 
691
 
 
692
#line 223 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
693
class PreIfndefDirective : public PreTreeComposite {
 
694
#line 695 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
695
  friend class ::CCExprResolve;
 
696
  friend class ::CExprResolve;
 
697
  friend class ::WinIfExists;
 
698
  friend class ::WinImportHandler;
 
699
  friend class ::WinMacros;
 
700
  friend class ::WinAsm;
 
701
  friend class ::WinDeclSpecs;
 
702
  friend class ::WinMemberExplSpec;
 
703
  friend class ::WinTypeKeywords;
 
704
  friend class ::WinFriend;
 
705
  friend class ::ExtAC;
 
706
  friend class ::ExtACBuilderCoupling;
 
707
  friend class ::ExtACSyntaxCoupling;
 
708
  friend class ::ExtACTree;
 
709
  friend class ::ExtACKeywords;
 
710
  friend class ::ExtGnu;
 
711
  friend class ::PragmaOnceUnitState;
 
712
  friend class ::PragmaOnce;
 
713
  friend class ::CMatchSyntax;
 
714
 
 
715
#line 223 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
716
 
 
717
public:
 
718
  /** Constructor. 
 
719
   *  \param i The \#ifndef token.
 
720
   *  \param n The name of the macro. 
 
721
   *  \param tl The remaining tokens of the line. */
 
722
  PreIfndefDirective (PreTree* i, PreTree* n, PreTree* tl) : PreTreeComposite (3, 1) { 
 
723
    add_son (i); add_son (n); add_son (tl); 
 
724
  }
 
725
  /** Constructor. 
 
726
   *  \param i The \#ifndef token.
 
727
   *  \param tl The remaining tokens of the line. */
 
728
  PreIfndefDirective (PreTree* i, PreTree* tl) : PreTreeComposite (2, 0) { 
 
729
    add_son (i); add_son (tl); 
 
730
  }
 
731
 
 
732
  /** Part of the tree visitor pattern. Calls the node
 
733
   *  visiting functions suitable for this node type. 
 
734
   *  \param v The visitor object on which to call the 
 
735
   *           visiting functions. */
 
736
  void accept (PreVisitor& v) {
 
737
    v.visitPreIfndefDirective_Pre (this);
 
738
    v.iterateNodes (this);
 
739
    v.visitPreIfndefDirective_Post (this);
 
740
  }
 
741
public:
 
742
  typedef AC::TLE __AttrTypes;
 
743
  const char *__attr_name (unsigned i) const { return 0; }
 
744
  const void *__attr (unsigned __i) const { return 0; }
 
745
#line 248 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
746
};      
 
747
 
 
748
 
 
749
/** \class PreElifDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
750
 *  Preprocessor tree node representing an \#elif directive. 
 
751
 *  Example: \code #elif OSTYPE==linux \endcode */
 
752
 
 
753
#line 754 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
754
} // closed Puma
 
755
class CCExprResolve;
 
756
class CExprResolve;
 
757
class WinIfExists;
 
758
class WinImportHandler;
 
759
class WinMacros;
 
760
class WinAsm;
 
761
class WinDeclSpecs;
 
762
class WinMemberExplSpec;
 
763
class WinTypeKeywords;
 
764
class WinFriend;
 
765
class ExtAC;
 
766
class ExtACBuilderCoupling;
 
767
class ExtACSyntaxCoupling;
 
768
class ExtACTree;
 
769
class ExtACKeywords;
 
770
class ExtGnu;
 
771
class PragmaOnceUnitState;
 
772
class PragmaOnce;
 
773
class CMatchSyntax;
 
774
namespace Puma {
 
775
 
 
776
#line 254 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
777
class PreElifDirective : public PreTreeComposite {
 
778
#line 779 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
779
  friend class ::CCExprResolve;
 
780
  friend class ::CExprResolve;
 
781
  friend class ::WinIfExists;
 
782
  friend class ::WinImportHandler;
 
783
  friend class ::WinMacros;
 
784
  friend class ::WinAsm;
 
785
  friend class ::WinDeclSpecs;
 
786
  friend class ::WinMemberExplSpec;
 
787
  friend class ::WinTypeKeywords;
 
788
  friend class ::WinFriend;
 
789
  friend class ::ExtAC;
 
790
  friend class ::ExtACBuilderCoupling;
 
791
  friend class ::ExtACSyntaxCoupling;
 
792
  friend class ::ExtACTree;
 
793
  friend class ::ExtACKeywords;
 
794
  friend class ::ExtGnu;
 
795
  friend class ::PragmaOnceUnitState;
 
796
  friend class ::PragmaOnce;
 
797
  friend class ::CMatchSyntax;
 
798
 
 
799
#line 254 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
800
 
 
801
public:
 
802
  /** Constructor. 
 
803
   *  \param e The \#elif token.
 
804
   *  \param c The condition. */
 
805
  PreElifDirective (PreTree* e, PreTree* c) : PreTreeComposite (2, 1) { 
 
806
    add_son (e); add_son (c); 
 
807
  }
 
808
 
 
809
  /** Part of the tree visitor pattern. Calls the node
 
810
   *  visiting functions suitable for this node type. 
 
811
   *  \param v The visitor object on which to call the 
 
812
   *           visiting functions. */
 
813
  void accept (PreVisitor& v) {
 
814
    v.visitPreElifDirective_Pre (this);
 
815
    v.iterateNodes (this);
 
816
    v.visitPreElifDirective_Post (this);
 
817
  }
 
818
public:
 
819
  typedef AC::TLE __AttrTypes;
 
820
  const char *__attr_name (unsigned i) const { return 0; }
 
821
  const void *__attr (unsigned __i) const { return 0; }
 
822
#line 272 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
823
};      
 
824
 
 
825
 
 
826
/** \class PreElseDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
827
 *  Preprocessor tree node representing an \#else directive. 
 
828
 *  Example: \code #else \endcode */
 
829
 
 
830
#line 831 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
831
} // closed Puma
 
832
class CCExprResolve;
 
833
class CExprResolve;
 
834
class WinIfExists;
 
835
class WinImportHandler;
 
836
class WinMacros;
 
837
class WinAsm;
 
838
class WinDeclSpecs;
 
839
class WinMemberExplSpec;
 
840
class WinTypeKeywords;
 
841
class WinFriend;
 
842
class ExtAC;
 
843
class ExtACBuilderCoupling;
 
844
class ExtACSyntaxCoupling;
 
845
class ExtACTree;
 
846
class ExtACKeywords;
 
847
class ExtGnu;
 
848
class PragmaOnceUnitState;
 
849
class PragmaOnce;
 
850
class CMatchSyntax;
 
851
namespace Puma {
 
852
 
 
853
#line 278 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
854
class PreElseDirective : public PreTreeComposite {
 
855
#line 856 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
856
  friend class ::CCExprResolve;
 
857
  friend class ::CExprResolve;
 
858
  friend class ::WinIfExists;
 
859
  friend class ::WinImportHandler;
 
860
  friend class ::WinMacros;
 
861
  friend class ::WinAsm;
 
862
  friend class ::WinDeclSpecs;
 
863
  friend class ::WinMemberExplSpec;
 
864
  friend class ::WinTypeKeywords;
 
865
  friend class ::WinFriend;
 
866
  friend class ::ExtAC;
 
867
  friend class ::ExtACBuilderCoupling;
 
868
  friend class ::ExtACSyntaxCoupling;
 
869
  friend class ::ExtACTree;
 
870
  friend class ::ExtACKeywords;
 
871
  friend class ::ExtGnu;
 
872
  friend class ::PragmaOnceUnitState;
 
873
  friend class ::PragmaOnce;
 
874
  friend class ::CMatchSyntax;
 
875
 
 
876
#line 278 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
877
 
 
878
public:
 
879
  /** Constructor. 
 
880
   *  \param e The \#else token.
 
881
   *  \param tl The remaining tokens of the line. */
 
882
  PreElseDirective (PreTree* e, PreTree* tl) : PreTreeComposite (2, 0) { 
 
883
    add_son (e); add_son (tl); 
 
884
  }
 
885
 
 
886
  /** Part of the tree visitor pattern. Calls the node
 
887
   *  visiting functions suitable for this node type. 
 
888
   *  \param v The visitor object on which to call the 
 
889
   *           visiting functions. */
 
890
  void accept (PreVisitor& v) {
 
891
    v.visitPreElseDirective_Pre (this);
 
892
    v.iterateNodes (this);
 
893
    v.visitPreElseDirective_Post (this);
 
894
  }
 
895
public:
 
896
  typedef AC::TLE __AttrTypes;
 
897
  const char *__attr_name (unsigned i) const { return 0; }
 
898
  const void *__attr (unsigned __i) const { return 0; }
 
899
#line 296 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
900
};      
 
901
 
 
902
 
 
903
/** \class PreEndifDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
904
 *  Preprocessor tree node representing an \#endif directive. 
 
905
 *  Example: \code #endif \endcode */
 
906
 
 
907
#line 908 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
908
} // closed Puma
 
909
class CCExprResolve;
 
910
class CExprResolve;
 
911
class WinIfExists;
 
912
class WinImportHandler;
 
913
class WinMacros;
 
914
class WinAsm;
 
915
class WinDeclSpecs;
 
916
class WinMemberExplSpec;
 
917
class WinTypeKeywords;
 
918
class WinFriend;
 
919
class ExtAC;
 
920
class ExtACBuilderCoupling;
 
921
class ExtACSyntaxCoupling;
 
922
class ExtACTree;
 
923
class ExtACKeywords;
 
924
class ExtGnu;
 
925
class PragmaOnceUnitState;
 
926
class PragmaOnce;
 
927
class CMatchSyntax;
 
928
namespace Puma {
 
929
 
 
930
#line 302 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
931
class PreEndifDirective : public PreTreeComposite {
 
932
#line 933 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
933
  friend class ::CCExprResolve;
 
934
  friend class ::CExprResolve;
 
935
  friend class ::WinIfExists;
 
936
  friend class ::WinImportHandler;
 
937
  friend class ::WinMacros;
 
938
  friend class ::WinAsm;
 
939
  friend class ::WinDeclSpecs;
 
940
  friend class ::WinMemberExplSpec;
 
941
  friend class ::WinTypeKeywords;
 
942
  friend class ::WinFriend;
 
943
  friend class ::ExtAC;
 
944
  friend class ::ExtACBuilderCoupling;
 
945
  friend class ::ExtACSyntaxCoupling;
 
946
  friend class ::ExtACTree;
 
947
  friend class ::ExtACKeywords;
 
948
  friend class ::ExtGnu;
 
949
  friend class ::PragmaOnceUnitState;
 
950
  friend class ::PragmaOnce;
 
951
  friend class ::CMatchSyntax;
 
952
 
 
953
#line 302 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
954
 
 
955
public:
 
956
  /** Constructor. 
 
957
   *  \param e The \#endif token.
 
958
   *  \param tl The remaining tokens of the line. */
 
959
  PreEndifDirective (PreTree* e, PreTree* tl) : PreTreeComposite (2, 0) { 
 
960
    add_son (e); add_son (tl); 
 
961
  }
 
962
 
 
963
  /** Part of the tree visitor pattern. Calls the node
 
964
   *  visiting functions suitable for this node type. 
 
965
   *  \param v The visitor object on which to call the 
 
966
   *           visiting functions. */
 
967
  void accept (PreVisitor& v) {
 
968
    v.visitPreEndifDirective_Pre (this);
 
969
    v.iterateNodes (this);
 
970
    v.visitPreEndifDirective_Post (this);
 
971
  }
 
972
public:
 
973
  typedef AC::TLE __AttrTypes;
 
974
  const char *__attr_name (unsigned i) const { return 0; }
 
975
  const void *__attr (unsigned __i) const { return 0; }
 
976
#line 320 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
977
};      
 
978
 
 
979
 
 
980
/** \class PreIncludeDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
981
 *  Preprocessor tree node representing an \#include or \#include_next directive. 
 
982
 *  Example: \code #include <stdio.h> \endcode */
 
983
 
 
984
#line 985 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
985
} // closed Puma
 
986
class CCExprResolve;
 
987
class CExprResolve;
 
988
class WinIfExists;
 
989
class WinImportHandler;
 
990
class WinMacros;
 
991
class WinAsm;
 
992
class WinDeclSpecs;
 
993
class WinMemberExplSpec;
 
994
class WinTypeKeywords;
 
995
class WinFriend;
 
996
class ExtAC;
 
997
class ExtACBuilderCoupling;
 
998
class ExtACSyntaxCoupling;
 
999
class ExtACTree;
 
1000
class ExtACKeywords;
 
1001
class ExtGnu;
 
1002
class PragmaOnceUnitState;
 
1003
class PragmaOnce;
 
1004
class CMatchSyntax;
 
1005
namespace Puma {
 
1006
 
 
1007
#line 326 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1008
class PreIncludeDirective : public PreTreeComposite {
 
1009
#line 1010 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1010
  friend class ::CCExprResolve;
 
1011
  friend class ::CExprResolve;
 
1012
  friend class ::WinIfExists;
 
1013
  friend class ::WinImportHandler;
 
1014
  friend class ::WinMacros;
 
1015
  friend class ::WinAsm;
 
1016
  friend class ::WinDeclSpecs;
 
1017
  friend class ::WinMemberExplSpec;
 
1018
  friend class ::WinTypeKeywords;
 
1019
  friend class ::WinFriend;
 
1020
  friend class ::ExtAC;
 
1021
  friend class ::ExtACBuilderCoupling;
 
1022
  friend class ::ExtACSyntaxCoupling;
 
1023
  friend class ::ExtACTree;
 
1024
  friend class ::ExtACKeywords;
 
1025
  friend class ::ExtGnu;
 
1026
  friend class ::PragmaOnceUnitState;
 
1027
  friend class ::PragmaOnce;
 
1028
  friend class ::CMatchSyntax;
 
1029
 
 
1030
#line 326 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1031
 
 
1032
  int _depth; // depth of nested includes
 
1033
 
 
1034
public:
 
1035
  /** Constructor. 
 
1036
   *  \param i The \#include or \#include_next token. 
 
1037
   *  \param tl The remaining tokens of the line containing the file to include. */
 
1038
  PreIncludeDirective (PreTree* i, PreTree* tl) : PreTreeComposite (2, 1) { 
 
1039
    add_son (i); add_son (tl); 
 
1040
    _depth = -1; 
 
1041
  }
 
1042
 
 
1043
  /** Part of the tree visitor pattern. Calls the node
 
1044
   *  visiting functions suitable for this node type. 
 
1045
   *  \param v The visitor object on which to call the 
 
1046
   *           visiting functions. */
 
1047
  void accept (PreVisitor& v) {
 
1048
    v.visitPreIncludeDirective_Pre (this);
 
1049
    v.iterateNodes (this);
 
1050
    v.visitPreIncludeDirective_Post (this);
 
1051
  }
 
1052
        
 
1053
  /** Get the depth of nested inclusion. 
 
1054
   *  \return The depth or -1 for a top-level include. */
 
1055
  int depth () const {
 
1056
    return _depth;
 
1057
  }
 
1058
  /** Set the depth of nested inclusion. 
 
1059
   *  \param d The depth of inclusion. */
 
1060
  void depth (int d) {
 
1061
    _depth = d;
 
1062
  }
 
1063
        
 
1064
  /** Check if this is a forced include (given by command line). */
 
1065
  bool is_forced () const {
 
1066
    return !((Unit*)startToken ()->belonging_to ())->isFile ();
 
1067
  }
 
1068
public:
 
1069
  typedef AC::TL<int,AC::TLE > __AttrTypes;
 
1070
  const char *__attr_name (unsigned i) const {
 
1071
    static const char *names[] = { "_depth" }; return names[i];
 
1072
  }
 
1073
  const void *__attr (unsigned __i) const {
 
1074
    switch (__i) { case 0: return &_depth; default: return 0; }
 
1075
  }
 
1076
#line 363 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1077
};      
 
1078
 
 
1079
 
 
1080
/** \class PreAssertDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1081
 *  Preprocessor tree node representing an \#assert directive. 
 
1082
 *  Example: \code #assert OSTYPE (linux) \endcode */
 
1083
 
 
1084
#line 1085 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1085
} // closed Puma
 
1086
class CCExprResolve;
 
1087
class CExprResolve;
 
1088
class WinIfExists;
 
1089
class WinImportHandler;
 
1090
class WinMacros;
 
1091
class WinAsm;
 
1092
class WinDeclSpecs;
 
1093
class WinMemberExplSpec;
 
1094
class WinTypeKeywords;
 
1095
class WinFriend;
 
1096
class ExtAC;
 
1097
class ExtACBuilderCoupling;
 
1098
class ExtACSyntaxCoupling;
 
1099
class ExtACTree;
 
1100
class ExtACKeywords;
 
1101
class ExtGnu;
 
1102
class PragmaOnceUnitState;
 
1103
class PragmaOnce;
 
1104
class CMatchSyntax;
 
1105
namespace Puma {
 
1106
 
 
1107
#line 369 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1108
class PreAssertDirective : public PreTreeComposite {
 
1109
#line 1110 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1110
  friend class ::CCExprResolve;
 
1111
  friend class ::CExprResolve;
 
1112
  friend class ::WinIfExists;
 
1113
  friend class ::WinImportHandler;
 
1114
  friend class ::WinMacros;
 
1115
  friend class ::WinAsm;
 
1116
  friend class ::WinDeclSpecs;
 
1117
  friend class ::WinMemberExplSpec;
 
1118
  friend class ::WinTypeKeywords;
 
1119
  friend class ::WinFriend;
 
1120
  friend class ::ExtAC;
 
1121
  friend class ::ExtACBuilderCoupling;
 
1122
  friend class ::ExtACSyntaxCoupling;
 
1123
  friend class ::ExtACTree;
 
1124
  friend class ::ExtACKeywords;
 
1125
  friend class ::ExtGnu;
 
1126
  friend class ::PragmaOnceUnitState;
 
1127
  friend class ::PragmaOnce;
 
1128
  friend class ::CMatchSyntax;
 
1129
 
 
1130
#line 369 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1131
 
 
1132
public:
 
1133
  /** Constructor. 
 
1134
   *  \param a The \#assert token.
 
1135
   *  \param p The predicate name.
 
1136
   *  \param an The answer to the predicate. */
 
1137
  PreAssertDirective (PreTree* a, PreTree* p, PreTree* an) : PreTreeComposite (3, 0) { 
 
1138
    add_son (a); add_son (p); add_son (an); 
 
1139
  }
 
1140
  /** Constructor. 
 
1141
   *  \param a The \#assert token.
 
1142
   *  \param tl The remaining tokens of the line. */
 
1143
  PreAssertDirective (PreTree* a, PreTree* tl) : PreTreeComposite (2, 0) { 
 
1144
    add_son (a); add_son (tl); 
 
1145
  }
 
1146
 
 
1147
  /** Part of the tree visitor pattern. Calls the node
 
1148
   *  visiting functions suitable for this node type. 
 
1149
   *  \param v The visitor object on which to call the 
 
1150
   *           visiting functions. */
 
1151
  void accept (PreVisitor& v) {
 
1152
    v.visitPreAssertDirective_Pre (this);
 
1153
    v.iterateNodes (this);
 
1154
    v.visitPreAssertDirective_Post (this);
 
1155
  }
 
1156
public:
 
1157
  typedef AC::TLE __AttrTypes;
 
1158
  const char *__attr_name (unsigned i) const { return 0; }
 
1159
  const void *__attr (unsigned __i) const { return 0; }
 
1160
#line 394 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1161
};      
 
1162
 
 
1163
 
 
1164
/** \class PreUnassertDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1165
 *  Preprocessor tree node representing an \#unassert directive. 
 
1166
 *  Example: \code #unassert OSTYPE \endcode */
 
1167
 
 
1168
#line 1169 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1169
} // closed Puma
 
1170
class CCExprResolve;
 
1171
class CExprResolve;
 
1172
class WinIfExists;
 
1173
class WinImportHandler;
 
1174
class WinMacros;
 
1175
class WinAsm;
 
1176
class WinDeclSpecs;
 
1177
class WinMemberExplSpec;
 
1178
class WinTypeKeywords;
 
1179
class WinFriend;
 
1180
class ExtAC;
 
1181
class ExtACBuilderCoupling;
 
1182
class ExtACSyntaxCoupling;
 
1183
class ExtACTree;
 
1184
class ExtACKeywords;
 
1185
class ExtGnu;
 
1186
class PragmaOnceUnitState;
 
1187
class PragmaOnce;
 
1188
class CMatchSyntax;
 
1189
namespace Puma {
 
1190
 
 
1191
#line 400 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1192
class PreUnassertDirective : public PreTreeComposite {
 
1193
#line 1194 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1194
  friend class ::CCExprResolve;
 
1195
  friend class ::CExprResolve;
 
1196
  friend class ::WinIfExists;
 
1197
  friend class ::WinImportHandler;
 
1198
  friend class ::WinMacros;
 
1199
  friend class ::WinAsm;
 
1200
  friend class ::WinDeclSpecs;
 
1201
  friend class ::WinMemberExplSpec;
 
1202
  friend class ::WinTypeKeywords;
 
1203
  friend class ::WinFriend;
 
1204
  friend class ::ExtAC;
 
1205
  friend class ::ExtACBuilderCoupling;
 
1206
  friend class ::ExtACSyntaxCoupling;
 
1207
  friend class ::ExtACTree;
 
1208
  friend class ::ExtACKeywords;
 
1209
  friend class ::ExtGnu;
 
1210
  friend class ::PragmaOnceUnitState;
 
1211
  friend class ::PragmaOnce;
 
1212
  friend class ::CMatchSyntax;
 
1213
 
 
1214
#line 400 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1215
 
 
1216
public:
 
1217
  /** Constructor. 
 
1218
   *  \param ua The \#unassert token. 
 
1219
   *  \param n The name of the predicate.
 
1220
   *  \param tl The remaining tokens of the line. */
 
1221
  PreUnassertDirective (PreTree* ua, PreTree* n, PreTree* tl) : PreTreeComposite (3, 0) { 
 
1222
    add_son (ua); add_son (n); add_son (tl); 
 
1223
  }
 
1224
  /** Constructor. 
 
1225
   *  \param ua The \#unassert token. 
 
1226
   *  \param tl The remaining tokens of the line. */
 
1227
  PreUnassertDirective (PreTree* ua, PreTree* tl) : PreTreeComposite (2, 0) { 
 
1228
    add_son (ua); add_son (tl); 
 
1229
  }
 
1230
 
 
1231
  /** Part of the tree visitor pattern. Calls the node
 
1232
   *  visiting functions suitable for this node type. 
 
1233
   *  \param v The visitor object on which to call the 
 
1234
   *           visiting functions. */
 
1235
  void accept (PreVisitor& v) {
 
1236
    v.visitPreUnassertDirective_Pre (this);
 
1237
    v.iterateNodes (this);
 
1238
    v.visitPreUnassertDirective_Post (this);
 
1239
  }
 
1240
public:
 
1241
  typedef AC::TLE __AttrTypes;
 
1242
  const char *__attr_name (unsigned i) const { return 0; }
 
1243
  const void *__attr (unsigned __i) const { return 0; }
 
1244
#line 425 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1245
};      
 
1246
 
 
1247
 
 
1248
/** \class PreDefineFunctionDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1249
 *  Preprocessor tree node representing a \#define directive for function-like macros. 
 
1250
 *  Example: \code #define MUL(a,b) (a * b) \endcode */
 
1251
 
 
1252
#line 1253 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1253
} // closed Puma
 
1254
class CCExprResolve;
 
1255
class CExprResolve;
 
1256
class WinIfExists;
 
1257
class WinImportHandler;
 
1258
class WinMacros;
 
1259
class WinAsm;
 
1260
class WinDeclSpecs;
 
1261
class WinMemberExplSpec;
 
1262
class WinTypeKeywords;
 
1263
class WinFriend;
 
1264
class ExtAC;
 
1265
class ExtACBuilderCoupling;
 
1266
class ExtACSyntaxCoupling;
 
1267
class ExtACTree;
 
1268
class ExtACKeywords;
 
1269
class ExtGnu;
 
1270
class PragmaOnceUnitState;
 
1271
class PragmaOnce;
 
1272
class CMatchSyntax;
 
1273
namespace Puma {
 
1274
 
 
1275
#line 431 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1276
class PreDefineFunctionDirective : public PreTreeComposite {
 
1277
#line 1278 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1278
  friend class ::CCExprResolve;
 
1279
  friend class ::CExprResolve;
 
1280
  friend class ::WinIfExists;
 
1281
  friend class ::WinImportHandler;
 
1282
  friend class ::WinMacros;
 
1283
  friend class ::WinAsm;
 
1284
  friend class ::WinDeclSpecs;
 
1285
  friend class ::WinMemberExplSpec;
 
1286
  friend class ::WinTypeKeywords;
 
1287
  friend class ::WinFriend;
 
1288
  friend class ::ExtAC;
 
1289
  friend class ::ExtACBuilderCoupling;
 
1290
  friend class ::ExtACSyntaxCoupling;
 
1291
  friend class ::ExtACTree;
 
1292
  friend class ::ExtACKeywords;
 
1293
  friend class ::ExtGnu;
 
1294
  friend class ::PragmaOnceUnitState;
 
1295
  friend class ::PragmaOnce;
 
1296
  friend class ::CMatchSyntax;
 
1297
 
 
1298
#line 431 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1299
 
 
1300
public:
 
1301
  /** Constructor. 
 
1302
   *  \param a The \#define token.
 
1303
   *  \param b The macro name.
 
1304
   *  \param c Left parenthesis before the parameter list.
 
1305
   *  \param d The macro parameter list. 
 
1306
   *  \param e Comma before the last parameter.
 
1307
   *  \param f The token '...'.
 
1308
   *  \param g Right parenthesis behind the parameter list.
 
1309
   *  \param h The macro body. */
 
1310
  PreDefineFunctionDirective (PreTree* a, PreTree* b, PreTree* c, PreTree* d, 
 
1311
   PreTree* e, PreTree* f, PreTree* g, PreTree* h) : PreTreeComposite (8, 0) { 
 
1312
    add_son (a); add_son (b); add_son (c); add_son (d);
 
1313
    add_son (e); add_son (f); add_son (g); add_son (h); 
 
1314
  }
 
1315
 
 
1316
  /** Constructor. 
 
1317
   *  \param a The \#define token.
 
1318
   *  \param b The macro name.
 
1319
   *  \param c Left parenthesis before the parameter list.
 
1320
   *  \param d The macro parameter list. 
 
1321
   *  \param e The token '...'.
 
1322
   *  \param f Right parenthesis behind the parameter list.
 
1323
   *  \param g The macro body. */
 
1324
  PreDefineFunctionDirective (PreTree* a, PreTree* b, PreTree* c, PreTree* d, 
 
1325
   PreTree* e, PreTree* f, PreTree* g) : PreTreeComposite (7, 0) { 
 
1326
    add_son (a); add_son (b); add_son (c); add_son (d);
 
1327
    add_son (e); add_son (f); add_son (g); 
 
1328
  }
 
1329
 
 
1330
  /** Constructor. 
 
1331
   *  \param a The \#define token.
 
1332
   *  \param b The macro name.
 
1333
   *  \param c Left parenthesis before the parameter list.
 
1334
   *  \param d The macro parameter list. 
 
1335
   *  \param e Right parenthesis behind the parameter list.
 
1336
   *  \param f The macro body. */
 
1337
  PreDefineFunctionDirective (PreTree* a, PreTree* b, PreTree* c, PreTree* d, 
 
1338
   PreTree* e, PreTree* f) : PreTreeComposite (6, 0) { 
 
1339
    add_son (a); add_son (b); add_son (c); 
 
1340
    add_son (d); add_son (e); add_son (f); 
 
1341
  }
 
1342
        
 
1343
  /** Constructor. 
 
1344
   *  \param a The \#define token.
 
1345
   *  \param b The macro name.
 
1346
   *  \param c Left parenthesis before the parameter list.
 
1347
   *  \param d Right parenthesis behind the parameter list.
 
1348
   *  \param e The macro body. */
 
1349
  PreDefineFunctionDirective (PreTree* a, PreTree* b, PreTree* c, 
 
1350
   PreTree* d, PreTree* e) : PreTreeComposite (5, 0) { 
 
1351
    add_son (a); add_son (b); add_son (c); add_son (d); add_son (e); 
 
1352
  }
 
1353
 
 
1354
  /** Part of the tree visitor pattern. Calls the node
 
1355
   *  visiting functions suitable for this node type. 
 
1356
   *  \param v The visitor object on which to call the 
 
1357
   *           visiting functions. */
 
1358
  void accept (PreVisitor& v) {
 
1359
    v.visitPreDefineFunctionDirective_Pre (this);
 
1360
    v.iterateNodes (this);
 
1361
    v.visitPreDefineFunctionDirective_Post (this);
 
1362
  }
 
1363
public:
 
1364
  typedef AC::TLE __AttrTypes;
 
1365
  const char *__attr_name (unsigned i) const { return 0; }
 
1366
  const void *__attr (unsigned __i) const { return 0; }
 
1367
#line 495 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1368
};   
 
1369
 
 
1370
 
 
1371
/** \class PreDefineConstantDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1372
 *  Preprocessor tree node representing a \#define directive for constants. 
 
1373
 *  Example: \code #define CONSTANT 1 \endcode */
 
1374
 
 
1375
#line 1376 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1376
} // closed Puma
 
1377
class CCExprResolve;
 
1378
class CExprResolve;
 
1379
class WinIfExists;
 
1380
class WinImportHandler;
 
1381
class WinMacros;
 
1382
class WinAsm;
 
1383
class WinDeclSpecs;
 
1384
class WinMemberExplSpec;
 
1385
class WinTypeKeywords;
 
1386
class WinFriend;
 
1387
class ExtAC;
 
1388
class ExtACBuilderCoupling;
 
1389
class ExtACSyntaxCoupling;
 
1390
class ExtACTree;
 
1391
class ExtACKeywords;
 
1392
class ExtGnu;
 
1393
class PragmaOnceUnitState;
 
1394
class PragmaOnce;
 
1395
class CMatchSyntax;
 
1396
namespace Puma {
 
1397
 
 
1398
#line 501 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1399
class PreDefineConstantDirective : public PreTreeComposite {
 
1400
#line 1401 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1401
  friend class ::CCExprResolve;
 
1402
  friend class ::CExprResolve;
 
1403
  friend class ::WinIfExists;
 
1404
  friend class ::WinImportHandler;
 
1405
  friend class ::WinMacros;
 
1406
  friend class ::WinAsm;
 
1407
  friend class ::WinDeclSpecs;
 
1408
  friend class ::WinMemberExplSpec;
 
1409
  friend class ::WinTypeKeywords;
 
1410
  friend class ::WinFriend;
 
1411
  friend class ::ExtAC;
 
1412
  friend class ::ExtACBuilderCoupling;
 
1413
  friend class ::ExtACSyntaxCoupling;
 
1414
  friend class ::ExtACTree;
 
1415
  friend class ::ExtACKeywords;
 
1416
  friend class ::ExtGnu;
 
1417
  friend class ::PragmaOnceUnitState;
 
1418
  friend class ::PragmaOnce;
 
1419
  friend class ::CMatchSyntax;
 
1420
 
 
1421
#line 501 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1422
 
 
1423
public:
 
1424
  /** Constructor. 
 
1425
   *  \param d The \#define token.
 
1426
   *  \param n The name of the constant.
 
1427
   *  \param v The constant value. */
 
1428
  PreDefineConstantDirective (PreTree* d, PreTree* n, PreTree* v) : PreTreeComposite (3, 0) { 
 
1429
    add_son (d); add_son (n); add_son (v); 
 
1430
  }
 
1431
  /** Constructor. 
 
1432
   *  \param d The \#define token.
 
1433
   *  \param tl The remaining tokens of the line. */
 
1434
  PreDefineConstantDirective (PreTree* d, PreTree* tl) : PreTreeComposite (2, 0) { 
 
1435
    add_son (d); add_son (tl); 
 
1436
  }
 
1437
 
 
1438
  /** Part of the tree visitor pattern. Calls the node
 
1439
   *  visiting functions suitable for this node type. 
 
1440
   *  \param v The visitor object on which to call the 
 
1441
   *           visiting functions. */
 
1442
  void accept (PreVisitor& v) {
 
1443
    v.visitPreDefineConstantDirective_Pre (this);
 
1444
    v.iterateNodes (this);
 
1445
    v.visitPreDefineConstantDirective_Post (this);
 
1446
  }
 
1447
public:
 
1448
  typedef AC::TLE __AttrTypes;
 
1449
  const char *__attr_name (unsigned i) const { return 0; }
 
1450
  const void *__attr (unsigned __i) const { return 0; }
 
1451
#line 526 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1452
};      
 
1453
 
 
1454
 
 
1455
/** \class PreUndefDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1456
 *  Preprocessor tree node representing an \#undef directive. 
 
1457
 *  Example: \code #undef MACRO \endcode */
 
1458
 
 
1459
#line 1460 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1460
} // closed Puma
 
1461
class CCExprResolve;
 
1462
class CExprResolve;
 
1463
class WinIfExists;
 
1464
class WinImportHandler;
 
1465
class WinMacros;
 
1466
class WinAsm;
 
1467
class WinDeclSpecs;
 
1468
class WinMemberExplSpec;
 
1469
class WinTypeKeywords;
 
1470
class WinFriend;
 
1471
class ExtAC;
 
1472
class ExtACBuilderCoupling;
 
1473
class ExtACSyntaxCoupling;
 
1474
class ExtACTree;
 
1475
class ExtACKeywords;
 
1476
class ExtGnu;
 
1477
class PragmaOnceUnitState;
 
1478
class PragmaOnce;
 
1479
class CMatchSyntax;
 
1480
namespace Puma {
 
1481
 
 
1482
#line 532 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1483
class PreUndefDirective : public PreTreeComposite {
 
1484
#line 1485 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1485
  friend class ::CCExprResolve;
 
1486
  friend class ::CExprResolve;
 
1487
  friend class ::WinIfExists;
 
1488
  friend class ::WinImportHandler;
 
1489
  friend class ::WinMacros;
 
1490
  friend class ::WinAsm;
 
1491
  friend class ::WinDeclSpecs;
 
1492
  friend class ::WinMemberExplSpec;
 
1493
  friend class ::WinTypeKeywords;
 
1494
  friend class ::WinFriend;
 
1495
  friend class ::ExtAC;
 
1496
  friend class ::ExtACBuilderCoupling;
 
1497
  friend class ::ExtACSyntaxCoupling;
 
1498
  friend class ::ExtACTree;
 
1499
  friend class ::ExtACKeywords;
 
1500
  friend class ::ExtGnu;
 
1501
  friend class ::PragmaOnceUnitState;
 
1502
  friend class ::PragmaOnce;
 
1503
  friend class ::CMatchSyntax;
 
1504
 
 
1505
#line 532 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1506
 
 
1507
public:
 
1508
  /** Constructor. 
 
1509
   *  \param u The \#undef token. 
 
1510
   *  \param m The name of the macro to undefine. 
 
1511
   *  \param tl The remaining tokens of the line. */
 
1512
  PreUndefDirective (PreTree* u, PreTree* m, PreTree* tl) : PreTreeComposite (3, 0) { 
 
1513
    add_son (u); add_son (m); add_son (tl); 
 
1514
  }
 
1515
  /** Constructor. 
 
1516
   *  \param u The \#undef token.
 
1517
   *  \param tl The remaining tokens of the line. */
 
1518
  PreUndefDirective (PreTree* u, PreTree* tl) : PreTreeComposite (2, 0) { 
 
1519
    add_son (u); add_son (tl); 
 
1520
  }
 
1521
 
 
1522
  /** Part of the tree visitor pattern. Calls the node
 
1523
   *  visiting functions suitable for this node type. 
 
1524
   *  \param v The visitor object on which to call the 
 
1525
   *           visiting functions. */
 
1526
  void accept (PreVisitor& v) {
 
1527
    v.visitPreUndefDirective_Pre (this);
 
1528
    v.iterateNodes (this);
 
1529
    v.visitPreUndefDirective_Post (this);
 
1530
  }
 
1531
public:
 
1532
  typedef AC::TLE __AttrTypes;
 
1533
  const char *__attr_name (unsigned i) const { return 0; }
 
1534
  const void *__attr (unsigned __i) const { return 0; }
 
1535
#line 557 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1536
};      
 
1537
 
 
1538
 
 
1539
/** \class PreWarningDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1540
 *  Preprocessor tree node representing a \#warning directive. 
 
1541
 *  Example: \code #warning This is a warning. \endcode */
 
1542
 
 
1543
#line 1544 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1544
} // closed Puma
 
1545
class CCExprResolve;
 
1546
class CExprResolve;
 
1547
class WinIfExists;
 
1548
class WinImportHandler;
 
1549
class WinMacros;
 
1550
class WinAsm;
 
1551
class WinDeclSpecs;
 
1552
class WinMemberExplSpec;
 
1553
class WinTypeKeywords;
 
1554
class WinFriend;
 
1555
class ExtAC;
 
1556
class ExtACBuilderCoupling;
 
1557
class ExtACSyntaxCoupling;
 
1558
class ExtACTree;
 
1559
class ExtACKeywords;
 
1560
class ExtGnu;
 
1561
class PragmaOnceUnitState;
 
1562
class PragmaOnce;
 
1563
class CMatchSyntax;
 
1564
namespace Puma {
 
1565
 
 
1566
#line 563 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1567
class PreWarningDirective : public PreTreeComposite {
 
1568
#line 1569 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1569
  friend class ::CCExprResolve;
 
1570
  friend class ::CExprResolve;
 
1571
  friend class ::WinIfExists;
 
1572
  friend class ::WinImportHandler;
 
1573
  friend class ::WinMacros;
 
1574
  friend class ::WinAsm;
 
1575
  friend class ::WinDeclSpecs;
 
1576
  friend class ::WinMemberExplSpec;
 
1577
  friend class ::WinTypeKeywords;
 
1578
  friend class ::WinFriend;
 
1579
  friend class ::ExtAC;
 
1580
  friend class ::ExtACBuilderCoupling;
 
1581
  friend class ::ExtACSyntaxCoupling;
 
1582
  friend class ::ExtACTree;
 
1583
  friend class ::ExtACKeywords;
 
1584
  friend class ::ExtGnu;
 
1585
  friend class ::PragmaOnceUnitState;
 
1586
  friend class ::PragmaOnce;
 
1587
  friend class ::CMatchSyntax;
 
1588
 
 
1589
#line 563 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1590
 
 
1591
public:
 
1592
  /** Constructor. 
 
1593
   *  \param w The \#warning token. 
 
1594
   *  \param m The warning message. */
 
1595
  PreWarningDirective (PreTree* w, PreTree* m) : PreTreeComposite (2, 0) { 
 
1596
    add_son (w); add_son (m); 
 
1597
  }
 
1598
 
 
1599
  /** Part of the tree visitor pattern. Calls the node
 
1600
   *  visiting functions suitable for this node type. 
 
1601
   *  \param v The visitor object on which to call the 
 
1602
   *           visiting functions. */
 
1603
  void accept (PreVisitor& v) {
 
1604
    v.visitPreWarningDirective_Pre (this);
 
1605
    v.iterateNodes (this);
 
1606
    v.visitPreWarningDirective_Post (this);
 
1607
  }
 
1608
public:
 
1609
  typedef AC::TLE __AttrTypes;
 
1610
  const char *__attr_name (unsigned i) const { return 0; }
 
1611
  const void *__attr (unsigned __i) const { return 0; }
 
1612
#line 581 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1613
};      
 
1614
 
 
1615
 
 
1616
/** \class PreErrorDirective PreTreeNodes.h Puma/PreTreeNodes.h
 
1617
 *  Preprocessor tree node representing an \#error directive. 
 
1618
 *  Example: \code #error This is an error. \endcode */
 
1619
 
 
1620
#line 1621 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1621
} // closed Puma
 
1622
class CCExprResolve;
 
1623
class CExprResolve;
 
1624
class WinIfExists;
 
1625
class WinImportHandler;
 
1626
class WinMacros;
 
1627
class WinAsm;
 
1628
class WinDeclSpecs;
 
1629
class WinMemberExplSpec;
 
1630
class WinTypeKeywords;
 
1631
class WinFriend;
 
1632
class ExtAC;
 
1633
class ExtACBuilderCoupling;
 
1634
class ExtACSyntaxCoupling;
 
1635
class ExtACTree;
 
1636
class ExtACKeywords;
 
1637
class ExtGnu;
 
1638
class PragmaOnceUnitState;
 
1639
class PragmaOnce;
 
1640
class CMatchSyntax;
 
1641
namespace Puma {
 
1642
 
 
1643
#line 587 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1644
class PreErrorDirective : public PreTreeComposite {
 
1645
#line 1646 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1646
  friend class ::CCExprResolve;
 
1647
  friend class ::CExprResolve;
 
1648
  friend class ::WinIfExists;
 
1649
  friend class ::WinImportHandler;
 
1650
  friend class ::WinMacros;
 
1651
  friend class ::WinAsm;
 
1652
  friend class ::WinDeclSpecs;
 
1653
  friend class ::WinMemberExplSpec;
 
1654
  friend class ::WinTypeKeywords;
 
1655
  friend class ::WinFriend;
 
1656
  friend class ::ExtAC;
 
1657
  friend class ::ExtACBuilderCoupling;
 
1658
  friend class ::ExtACSyntaxCoupling;
 
1659
  friend class ::ExtACTree;
 
1660
  friend class ::ExtACKeywords;
 
1661
  friend class ::ExtGnu;
 
1662
  friend class ::PragmaOnceUnitState;
 
1663
  friend class ::PragmaOnce;
 
1664
  friend class ::CMatchSyntax;
 
1665
 
 
1666
#line 587 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1667
 
 
1668
public:
 
1669
  /** Constructor. 
 
1670
   *  \param e The \#error token.
 
1671
   *  \param m The error message. */
 
1672
  PreErrorDirective (PreTree* e, PreTree* m) : PreTreeComposite (2, 0) { 
 
1673
    add_son (e); add_son (m); 
 
1674
  }
 
1675
 
 
1676
  /** Part of the tree visitor pattern. Calls the node
 
1677
   *  visiting functions suitable for this node type. 
 
1678
   *  \param v The visitor object on which to call the 
 
1679
   *           visiting functions. */
 
1680
  void accept (PreVisitor& v) {
 
1681
    v.visitPreErrorDirective_Pre (this);
 
1682
    v.iterateNodes (this);
 
1683
    v.visitPreErrorDirective_Post (this);
 
1684
  }
 
1685
public:
 
1686
  typedef AC::TLE __AttrTypes;
 
1687
  const char *__attr_name (unsigned i) const { return 0; }
 
1688
  const void *__attr (unsigned __i) const { return 0; }
 
1689
#line 605 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1690
};      
 
1691
 
 
1692
 
 
1693
/** \class PreIdentifierList PreTreeNodes.h Puma/PreTreeNodes.h
 
1694
 *  Preprocessor tree node representing the identifier list of a 
 
1695
 *  function-like macro definition. 
 
1696
 *  Example: \code a,b,c \endcode */
 
1697
 
 
1698
#line 1699 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1699
} // closed Puma
 
1700
class CCExprResolve;
 
1701
class CExprResolve;
 
1702
class WinIfExists;
 
1703
class WinImportHandler;
 
1704
class WinMacros;
 
1705
class WinAsm;
 
1706
class WinDeclSpecs;
 
1707
class WinMemberExplSpec;
 
1708
class WinTypeKeywords;
 
1709
class WinFriend;
 
1710
class ExtAC;
 
1711
class ExtACBuilderCoupling;
 
1712
class ExtACSyntaxCoupling;
 
1713
class ExtACTree;
 
1714
class ExtACKeywords;
 
1715
class ExtGnu;
 
1716
class PragmaOnceUnitState;
 
1717
class PragmaOnce;
 
1718
class CMatchSyntax;
 
1719
namespace Puma {
 
1720
 
 
1721
#line 612 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1722
class PreIdentifierList : public PreTreeComposite {
 
1723
#line 1724 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1724
  friend class ::CCExprResolve;
 
1725
  friend class ::CExprResolve;
 
1726
  friend class ::WinIfExists;
 
1727
  friend class ::WinImportHandler;
 
1728
  friend class ::WinMacros;
 
1729
  friend class ::WinAsm;
 
1730
  friend class ::WinDeclSpecs;
 
1731
  friend class ::WinMemberExplSpec;
 
1732
  friend class ::WinTypeKeywords;
 
1733
  friend class ::WinFriend;
 
1734
  friend class ::ExtAC;
 
1735
  friend class ::ExtACBuilderCoupling;
 
1736
  friend class ::ExtACSyntaxCoupling;
 
1737
  friend class ::ExtACTree;
 
1738
  friend class ::ExtACKeywords;
 
1739
  friend class ::ExtGnu;
 
1740
  friend class ::PragmaOnceUnitState;
 
1741
  friend class ::PragmaOnce;
 
1742
  friend class ::CMatchSyntax;
 
1743
 
 
1744
#line 612 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1745
 
 
1746
public:
 
1747
  /** Constructor. 
 
1748
   *  \param id An identifier. */
 
1749
  PreIdentifierList (PreTree* id) : PreTreeComposite (-1, 0) { 
 
1750
    add_son (id); 
 
1751
  }
 
1752
        
 
1753
  /** Add two sons, a comma and an identifier.
 
1754
   *  \param c A comma.
 
1755
   *  \param id An identifier. */
 
1756
  void addSons (PreTree* c, PreTree* id) { 
 
1757
    add_son (c); add_son (id); 
 
1758
  }
 
1759
 
 
1760
  /** Part of the tree visitor pattern. Calls the node
 
1761
   *  visiting functions suitable for this node type. 
 
1762
   *  \param v The visitor object on which to call the 
 
1763
   *           visiting functions. */
 
1764
  void accept (PreVisitor& v) {
 
1765
    v.visitPreIdentifierList_Pre (this);
 
1766
    v.iterateNodes (this);
 
1767
    v.visitPreIdentifierList_Post (this);
 
1768
  }
 
1769
public:
 
1770
  typedef AC::TLE __AttrTypes;
 
1771
  const char *__attr_name (unsigned i) const { return 0; }
 
1772
  const void *__attr (unsigned __i) const { return 0; }
 
1773
#line 636 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1774
};
 
1775
 
 
1776
 
 
1777
/** \class PreTokenList PreTreeNodes.h Puma/PreTreeNodes.h
 
1778
 *  Preprocessor tree node representing the token list of a macro body. */
 
1779
 
 
1780
#line 1781 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1781
} // closed Puma
 
1782
class CCExprResolve;
 
1783
class CExprResolve;
 
1784
class WinIfExists;
 
1785
class WinImportHandler;
 
1786
class WinMacros;
 
1787
class WinAsm;
 
1788
class WinDeclSpecs;
 
1789
class WinMemberExplSpec;
 
1790
class WinTypeKeywords;
 
1791
class WinFriend;
 
1792
class ExtAC;
 
1793
class ExtACBuilderCoupling;
 
1794
class ExtACSyntaxCoupling;
 
1795
class ExtACTree;
 
1796
class ExtACKeywords;
 
1797
class ExtGnu;
 
1798
class PragmaOnceUnitState;
 
1799
class PragmaOnce;
 
1800
class CMatchSyntax;
 
1801
namespace Puma {
 
1802
 
 
1803
#line 641 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1804
class PreTokenList : public PreTreeComposite {
 
1805
#line 1806 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1806
  friend class ::CCExprResolve;
 
1807
  friend class ::CExprResolve;
 
1808
  friend class ::WinIfExists;
 
1809
  friend class ::WinImportHandler;
 
1810
  friend class ::WinMacros;
 
1811
  friend class ::WinAsm;
 
1812
  friend class ::WinDeclSpecs;
 
1813
  friend class ::WinMemberExplSpec;
 
1814
  friend class ::WinTypeKeywords;
 
1815
  friend class ::WinFriend;
 
1816
  friend class ::ExtAC;
 
1817
  friend class ::ExtACBuilderCoupling;
 
1818
  friend class ::ExtACSyntaxCoupling;
 
1819
  friend class ::ExtACTree;
 
1820
  friend class ::ExtACKeywords;
 
1821
  friend class ::ExtGnu;
 
1822
  friend class ::PragmaOnceUnitState;
 
1823
  friend class ::PragmaOnce;
 
1824
  friend class ::CMatchSyntax;
 
1825
 
 
1826
#line 641 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1827
 
 
1828
public:
 
1829
  /** Constructor. */
 
1830
  PreTokenList () : PreTreeComposite (0, 0) {}
 
1831
  /** Constructor. 
 
1832
   *  \param tl The token list. 
 
1833
   *  \param nl The newline token. */
 
1834
  PreTokenList (PreTree* tl, PreTree* nl) : PreTreeComposite (2, 0) { 
 
1835
    add_son (tl); add_son (nl); 
 
1836
  }
 
1837
  /** Constructor. 
 
1838
   *  \param tl The token list. */
 
1839
  PreTokenList (PreTree* tl) : PreTreeComposite (1, 0) { 
 
1840
    add_son (tl); 
 
1841
  }
 
1842
        
 
1843
  /** Part of the tree visitor pattern. Calls the node
 
1844
   *  visiting functions suitable for this node type. 
 
1845
   *  \param v The visitor object on which to call the 
 
1846
   *           visiting functions. */
 
1847
  void accept (PreVisitor& v) {
 
1848
    v.visitPreTokenList_Pre (this);
 
1849
    v.iterateNodes (this);
 
1850
    v.visitPreTokenList_Post (this);
 
1851
  }
 
1852
public:
 
1853
  typedef AC::TLE __AttrTypes;
 
1854
  const char *__attr_name (unsigned i) const { return 0; }
 
1855
  const void *__attr (unsigned __i) const { return 0; }
 
1856
#line 666 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1857
};      
 
1858
 
 
1859
 
 
1860
/** \class PreTokenListPart PreTreeNodes.h Puma/PreTreeNodes.h
 
1861
 *  Preprocessor tree node representing a part of the token list of a macro body. */
 
1862
 
 
1863
#line 1864 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1864
} // closed Puma
 
1865
class CCExprResolve;
 
1866
class CExprResolve;
 
1867
class WinIfExists;
 
1868
class WinImportHandler;
 
1869
class WinMacros;
 
1870
class WinAsm;
 
1871
class WinDeclSpecs;
 
1872
class WinMemberExplSpec;
 
1873
class WinTypeKeywords;
 
1874
class WinFriend;
 
1875
class ExtAC;
 
1876
class ExtACBuilderCoupling;
 
1877
class ExtACSyntaxCoupling;
 
1878
class ExtACTree;
 
1879
class ExtACKeywords;
 
1880
class ExtGnu;
 
1881
class PragmaOnceUnitState;
 
1882
class PragmaOnce;
 
1883
class CMatchSyntax;
 
1884
namespace Puma {
 
1885
 
 
1886
#line 671 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1887
class PreTokenListPart : public PreTreeComposite {
 
1888
#line 1889 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1889
  friend class ::CCExprResolve;
 
1890
  friend class ::CExprResolve;
 
1891
  friend class ::WinIfExists;
 
1892
  friend class ::WinImportHandler;
 
1893
  friend class ::WinMacros;
 
1894
  friend class ::WinAsm;
 
1895
  friend class ::WinDeclSpecs;
 
1896
  friend class ::WinMemberExplSpec;
 
1897
  friend class ::WinTypeKeywords;
 
1898
  friend class ::WinFriend;
 
1899
  friend class ::ExtAC;
 
1900
  friend class ::ExtACBuilderCoupling;
 
1901
  friend class ::ExtACSyntaxCoupling;
 
1902
  friend class ::ExtACTree;
 
1903
  friend class ::ExtACKeywords;
 
1904
  friend class ::ExtGnu;
 
1905
  friend class ::PragmaOnceUnitState;
 
1906
  friend class ::PragmaOnce;
 
1907
  friend class ::CMatchSyntax;
 
1908
 
 
1909
#line 671 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1910
 
 
1911
public:
 
1912
  /** Constructor. 
 
1913
   *  \param tl The token list. */
 
1914
  PreTokenListPart (PreTree* tl) : PreTreeComposite (-1, 0) { 
 
1915
    add_son (tl); 
 
1916
  }
 
1917
        
 
1918
  /** Part of the tree visitor pattern. Calls the node
 
1919
   *  visiting functions suitable for this node type. 
 
1920
   *  \param v The visitor object on which to call the 
 
1921
   *           visiting functions. */
 
1922
  void accept (PreVisitor& v) {
 
1923
    v.visitPreTokenListPart_Pre (this);
 
1924
    v.iterateNodes (this);
 
1925
    v.visitPreTokenListPart_Post (this);
 
1926
  }
 
1927
public:
 
1928
  typedef AC::TLE __AttrTypes;
 
1929
  const char *__attr_name (unsigned i) const { return 0; }
 
1930
  const void *__attr (unsigned __i) const { return 0; }
 
1931
#line 688 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1932
};      
 
1933
 
 
1934
 
 
1935
/** \class PreCondSemNode PreTreeNodes.h Puma/PreTreeNodes.h
 
1936
 *  Preprocessor semantic tree node for conditions. */
 
1937
 
 
1938
#line 1939 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1939
} // closed Puma
 
1940
class CCExprResolve;
 
1941
class CExprResolve;
 
1942
class WinIfExists;
 
1943
class WinImportHandler;
 
1944
class WinMacros;
 
1945
class WinAsm;
 
1946
class WinDeclSpecs;
 
1947
class WinMemberExplSpec;
 
1948
class WinTypeKeywords;
 
1949
class WinFriend;
 
1950
class ExtAC;
 
1951
class ExtACBuilderCoupling;
 
1952
class ExtACSyntaxCoupling;
 
1953
class ExtACTree;
 
1954
class ExtACKeywords;
 
1955
class ExtGnu;
 
1956
class PragmaOnceUnitState;
 
1957
class PragmaOnce;
 
1958
class CMatchSyntax;
 
1959
namespace Puma {
 
1960
 
 
1961
#line 693 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1962
class PreCondSemNode : public PreTree {
 
1963
#line 1964 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
1964
  friend class ::CCExprResolve;
 
1965
  friend class ::CExprResolve;
 
1966
  friend class ::WinIfExists;
 
1967
  friend class ::WinImportHandler;
 
1968
  friend class ::WinMacros;
 
1969
  friend class ::WinAsm;
 
1970
  friend class ::WinDeclSpecs;
 
1971
  friend class ::WinMemberExplSpec;
 
1972
  friend class ::WinTypeKeywords;
 
1973
  friend class ::WinFriend;
 
1974
  friend class ::ExtAC;
 
1975
  friend class ::ExtACBuilderCoupling;
 
1976
  friend class ::ExtACSyntaxCoupling;
 
1977
  friend class ::ExtACTree;
 
1978
  friend class ::ExtACKeywords;
 
1979
  friend class ::ExtGnu;
 
1980
  friend class ::PragmaOnceUnitState;
 
1981
  friend class ::PragmaOnce;
 
1982
  friend class ::CMatchSyntax;
 
1983
 
 
1984
#line 693 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
1985
 
 
1986
  // The calculated value of the condition.
 
1987
  bool _value;
 
1988
 
 
1989
public:
 
1990
  /** Constructor. 
 
1991
   *  \param value The calculated value of the condition. */
 
1992
  PreCondSemNode (bool value) : _value (value) {}
 
1993
        
 
1994
  /** Part of the tree visitor pattern. Calls the node
 
1995
   *  visiting functions suitable for this node type. 
 
1996
   *  \param v The visitor object on which to call the 
 
1997
   *           visiting functions. */
 
1998
  void accept (PreVisitor& v) {
 
1999
    v.visitPreCondSemNode (this);
 
2000
  }
 
2001
        
 
2002
  /** Get the calculated value of the condition. */
 
2003
  bool value () const { return _value; }
 
2004
public:
 
2005
  typedef AC::TL<bool,AC::TLE > __AttrTypes;
 
2006
  const char *__attr_name (unsigned i) const {
 
2007
    static const char *names[] = { "_value" }; return names[i];
 
2008
  }
 
2009
  const void *__attr (unsigned __i) const {
 
2010
    switch (__i) { case 0: return &_value; default: return 0; }
 
2011
  }
 
2012
#line 712 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2013
};      
 
2014
 
 
2015
 
 
2016
/** \class PreInclSemNode PreTreeNodes.h Puma/PreTreeNodes.h
 
2017
 *  Preprocessor semantic tree node for the \#include directive
 
2018
 *  containing the unit to include. */
 
2019
 
 
2020
#line 2021 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
2021
} // closed Puma
 
2022
class CCExprResolve;
 
2023
class CExprResolve;
 
2024
class WinIfExists;
 
2025
class WinImportHandler;
 
2026
class WinMacros;
 
2027
class WinAsm;
 
2028
class WinDeclSpecs;
 
2029
class WinMemberExplSpec;
 
2030
class WinTypeKeywords;
 
2031
class WinFriend;
 
2032
class ExtAC;
 
2033
class ExtACBuilderCoupling;
 
2034
class ExtACSyntaxCoupling;
 
2035
class ExtACTree;
 
2036
class ExtACKeywords;
 
2037
class ExtGnu;
 
2038
class PragmaOnceUnitState;
 
2039
class PragmaOnce;
 
2040
class CMatchSyntax;
 
2041
namespace Puma {
 
2042
 
 
2043
#line 718 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2044
class PreInclSemNode : public PreTree {
 
2045
#line 2046 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
2046
  friend class ::CCExprResolve;
 
2047
  friend class ::CExprResolve;
 
2048
  friend class ::WinIfExists;
 
2049
  friend class ::WinImportHandler;
 
2050
  friend class ::WinMacros;
 
2051
  friend class ::WinAsm;
 
2052
  friend class ::WinDeclSpecs;
 
2053
  friend class ::WinMemberExplSpec;
 
2054
  friend class ::WinTypeKeywords;
 
2055
  friend class ::WinFriend;
 
2056
  friend class ::ExtAC;
 
2057
  friend class ::ExtACBuilderCoupling;
 
2058
  friend class ::ExtACSyntaxCoupling;
 
2059
  friend class ::ExtACTree;
 
2060
  friend class ::ExtACKeywords;
 
2061
  friend class ::ExtGnu;
 
2062
  friend class ::PragmaOnceUnitState;
 
2063
  friend class ::PragmaOnce;
 
2064
  friend class ::CMatchSyntax;
 
2065
 
 
2066
#line 718 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2067
 
 
2068
  // Pointer to the included file unit.
 
2069
  Unit* _unit;
 
2070
        
 
2071
  // True if the inclusion was not done, because of an active include guard.
 
2072
  bool _guarded;
 
2073
 
 
2074
public:
 
2075
  /** Constructor. 
 
2076
   *  \param unit The unit containing the tokens of the include file.
 
2077
   *  \param guarded True if the inclusion was not done due to an include guard. */
 
2078
  PreInclSemNode (Unit* unit, bool guarded) :
 
2079
    _unit (unit), _guarded (guarded) {}
 
2080
        
 
2081
  /** Part of the tree visitor pattern. Calls the node
 
2082
   *  visiting functions suitable for this node type. 
 
2083
   *  \param v The visitor object on which to call the 
 
2084
   *           visiting functions. */
 
2085
  void accept (PreVisitor& v) {
 
2086
    v.visitPreInclSemNode (this);
 
2087
  }
 
2088
        
 
2089
  /** Get the token unit of the included file. */
 
2090
  Unit* unit () const { return _unit; }
 
2091
        
 
2092
  /** Check if the inclusion was not done due to an include guard. */
 
2093
  bool guarded () const { return _guarded; }
 
2094
public:
 
2095
  typedef AC::TL<Puma::Unit *,AC::TL<bool,AC::TLE > > __AttrTypes;
 
2096
  const char *__attr_name (unsigned i) const {
 
2097
    static const char *names[] = { "_unit", "_guarded" }; return names[i];
 
2098
  }
 
2099
  const void *__attr (unsigned __i) const {
 
2100
    switch (__i) { case 0: return &_unit; case 1: return &_guarded; default: return 0; }
 
2101
  }
 
2102
#line 745 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2103
};      
 
2104
 
 
2105
 
 
2106
/** \class PreError PreTreeNodes.h Puma/PreTreeNodes.h
 
2107
 *  Preprocessor tree node representing a parse error. */
 
2108
 
 
2109
#line 2110 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
2110
} // closed Puma
 
2111
class CCExprResolve;
 
2112
class CExprResolve;
 
2113
class WinIfExists;
 
2114
class WinImportHandler;
 
2115
class WinMacros;
 
2116
class WinAsm;
 
2117
class WinDeclSpecs;
 
2118
class WinMemberExplSpec;
 
2119
class WinTypeKeywords;
 
2120
class WinFriend;
 
2121
class ExtAC;
 
2122
class ExtACBuilderCoupling;
 
2123
class ExtACSyntaxCoupling;
 
2124
class ExtACTree;
 
2125
class ExtACKeywords;
 
2126
class ExtGnu;
 
2127
class PragmaOnceUnitState;
 
2128
class PragmaOnce;
 
2129
class CMatchSyntax;
 
2130
namespace Puma {
 
2131
 
 
2132
#line 750 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2133
class PreError : public PreTree {
 
2134
#line 2135 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
2135
  friend class ::CCExprResolve;
 
2136
  friend class ::CExprResolve;
 
2137
  friend class ::WinIfExists;
 
2138
  friend class ::WinImportHandler;
 
2139
  friend class ::WinMacros;
 
2140
  friend class ::WinAsm;
 
2141
  friend class ::WinDeclSpecs;
 
2142
  friend class ::WinMemberExplSpec;
 
2143
  friend class ::WinTypeKeywords;
 
2144
  friend class ::WinFriend;
 
2145
  friend class ::ExtAC;
 
2146
  friend class ::ExtACBuilderCoupling;
 
2147
  friend class ::ExtACSyntaxCoupling;
 
2148
  friend class ::ExtACTree;
 
2149
  friend class ::ExtACKeywords;
 
2150
  friend class ::ExtGnu;
 
2151
  friend class ::PragmaOnceUnitState;
 
2152
  friend class ::PragmaOnce;
 
2153
  friend class ::CMatchSyntax;
 
2154
 
 
2155
#line 750 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2156
 
 
2157
public:
 
2158
  /** Constructor. */
 
2159
  PreError () {}
 
2160
        
 
2161
  /** Part of the tree visitor pattern. Calls the node
 
2162
   *  visiting functions suitable for this node type. 
 
2163
   *  \param v The visitor object on which to call the 
 
2164
   *           visiting functions. */
 
2165
  void accept (PreVisitor& v) {
 
2166
    v.visitPreError (this);
 
2167
  }
 
2168
public:
 
2169
  typedef AC::TLE __AttrTypes;
 
2170
  const char *__attr_name (unsigned i) const { return 0; }
 
2171
  const void *__attr (unsigned __i) const { return 0; }
 
2172
#line 762 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step1/inc/Puma/PreTreeNodes.h"
 
2173
};      
1810
2174
 
1811
2175
 
1812
2176
} // namespace Puma
1813
2177
 
1814
2178
#endif /* __pre_syntax_tree_nodes__ */
1815
2179
 
1816
 
#line 1817 "/var/tmp/aspectc++/debian/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
 
2180
#line 2181 "/home/inf4/tartler/src/aspectc++/upstream/Puma/gen-release/step2/inc/Puma/PreTreeNodes.h"
1817
2181
 
1818
 
#ifdef __ac_FIRST_FILE__var_tmp_aspectc4343_debian_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
1819
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
1820
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
1821
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
 
2182
#ifdef __ac_FIRST_FILE__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
 
2183
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
 
2184
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
 
2185
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveCC_ah__
1822
2186
#include "CCExprResolveCC.ah"
1823
2187
#endif
1824
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1825
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2188
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2189
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1826
2190
#include "ExtACTree.ah"
1827
2191
#endif
1828
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
1829
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2192
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2193
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
1830
2194
#include "ExtGnu.ah"
1831
2195
#endif
1832
2196
#endif
1833
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
1834
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
1835
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
 
2197
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
 
2198
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
 
2199
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CCExprResolveH_ah__
1836
2200
#include "CCExprResolveH.ah"
1837
2201
#endif
1838
2202
#endif
1839
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
1840
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
1841
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
 
2203
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
 
2204
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
 
2205
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveCC_ah__
1842
2206
#include "CExprResolveCC.ah"
1843
2207
#endif
1844
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1845
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2208
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2209
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1846
2210
#include "ExtACTree.ah"
1847
2211
#endif
1848
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
1849
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2212
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2213
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
1850
2214
#include "ExtGnu.ah"
1851
2215
#endif
1852
2216
#endif
1853
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveH_ah__
1854
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveH_ah__
1855
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CExprResolveH_ah__
 
2217
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveH_ah__
 
2218
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveH_ah__
 
2219
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CExprResolveH_ah__
1856
2220
#include "CExprResolveH.ah"
1857
2221
#endif
1858
2222
#endif
1859
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinIfExists_ah__
1860
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinIfExists_ah__
1861
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinIfExists_ah__
 
2223
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinIfExists_ah__
 
2224
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinIfExists_ah__
 
2225
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinIfExists_ah__
1862
2226
#include "WinIfExists.ah"
1863
2227
#endif
1864
2228
#endif
1865
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinImportHandler_ah__
1866
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinImportHandler_ah__
1867
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinImportHandler_ah__
 
2229
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinImportHandler_ah__
 
2230
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinImportHandler_ah__
 
2231
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinImportHandler_ah__
1868
2232
#include "WinImportHandler.ah"
1869
2233
#endif
1870
2234
#endif
1871
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMacros_ah__
1872
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMacros_ah__
1873
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMacros_ah__
 
2235
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMacros_ah__
 
2236
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMacros_ah__
 
2237
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMacros_ah__
1874
2238
#include "WinMacros.ah"
1875
2239
#endif
1876
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1877
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2240
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2241
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1878
2242
#include "PragmaOnceUnitState.ah"
1879
2243
#endif
1880
2244
#endif
1881
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinAsm_ah__
1882
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinAsm_ah__
1883
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinAsm_ah__
 
2245
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinAsm_ah__
 
2246
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinAsm_ah__
 
2247
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinAsm_ah__
1884
2248
#include "WinAsm.ah"
1885
2249
#endif
1886
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1887
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2250
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2251
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1888
2252
#include "ExtACTree.ah"
1889
2253
#endif
1890
2254
#endif
1891
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
1892
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
1893
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
 
2255
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
 
2256
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
 
2257
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinDeclSpecs_ah__
1894
2258
#include "WinDeclSpecs.ah"
1895
2259
#endif
1896
2260
#endif
1897
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
1898
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
1899
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
 
2261
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
 
2262
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
 
2263
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinMemberExplSpec_ah__
1900
2264
#include "WinMemberExplSpec.ah"
1901
2265
#endif
1902
2266
#endif
1903
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
1904
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
1905
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
 
2267
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
 
2268
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
 
2269
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinTypeKeywords_ah__
1906
2270
#include "WinTypeKeywords.ah"
1907
2271
#endif
1908
2272
#endif
1909
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinFriend_ah__
1910
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinFriend_ah__
1911
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_WinFriend_ah__
 
2273
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinFriend_ah__
 
2274
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinFriend_ah__
 
2275
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_WinFriend_ah__
1912
2276
#include "WinFriend.ah"
1913
2277
#endif
1914
2278
#endif
1915
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtAC_ah__
1916
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtAC_ah__
1917
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtAC_ah__
 
2279
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtAC_ah__
 
2280
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtAC_ah__
 
2281
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtAC_ah__
1918
2282
#include "ExtAC.ah"
1919
2283
#endif
1920
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1921
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2284
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2285
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1922
2286
#include "ExtACTree.ah"
1923
2287
#endif
1924
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
1925
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
 
2288
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
 
2289
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
1926
2290
#include "ExtACKeywords.ah"
1927
2291
#endif
1928
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
1929
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2292
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2293
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
1930
2294
#include "ExtGnu.ah"
1931
2295
#endif
1932
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1933
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2296
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2297
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1934
2298
#include "PragmaOnceUnitState.ah"
1935
2299
#endif
1936
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
1937
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
 
2300
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
 
2301
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
1938
2302
#include "CMatchSyntax.ah"
1939
2303
#endif
1940
2304
#endif
1941
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
1942
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
1943
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
 
2305
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
 
2306
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
 
2307
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderH_ah__
1944
2308
#include "ExtACBuilderH.ah"
1945
2309
#endif
1946
2310
#endif
1947
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
1948
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
1949
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
 
2311
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
 
2312
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
 
2313
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACBuilderCC_ah__
1950
2314
#include "ExtACBuilderCC.ah"
1951
2315
#endif
1952
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1953
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2316
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2317
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1954
2318
#include "ExtACTree.ah"
1955
2319
#endif
1956
2320
#endif
1957
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
1958
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
1959
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
 
2321
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
 
2322
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
 
2323
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxH_ah__
1960
2324
#include "ExtACSyntaxH.ah"
1961
2325
#endif
1962
2326
#endif
1963
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
1964
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
1965
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
 
2327
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
 
2328
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
 
2329
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACSyntaxCC_ah__
1966
2330
#include "ExtACSyntaxCC.ah"
1967
2331
#endif
1968
2332
#endif
1969
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1970
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1971
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2333
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2334
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2335
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1972
2336
#include "ExtACTree.ah"
1973
2337
#endif
1974
2338
#endif
1975
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
1976
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
1977
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
 
2339
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
 
2340
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
 
2341
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACKeywords_ah__
1978
2342
#include "ExtACKeywords.ah"
1979
2343
#endif
1980
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1981
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2344
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2345
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
1982
2346
#include "PragmaOnceUnitState.ah"
1983
2347
#endif
1984
2348
#endif
1985
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
1986
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1987
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2349
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2350
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2351
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1988
2352
#include "ExtACTree.ah"
1989
2353
#endif
1990
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
1991
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2354
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
 
2355
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnu_ah__
1992
2356
#include "ExtGnu.ah"
1993
2357
#endif
1994
2358
#endif
1995
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
1996
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
1997
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2359
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
 
2360
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
 
2361
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtACTree_ah__
1998
2362
#include "ExtACTree.ah"
1999
2363
#endif
2000
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
2001
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
 
2364
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
 
2365
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_ExtGnuCSemDeclSpecs_ah__
2002
2366
#include "ExtGnuCSemDeclSpecs.ah"
2003
2367
#endif
2004
2368
#endif
2005
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
2006
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
2007
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
2008
 
#include "PragmaOnceUnitState.ah"
2009
 
#endif
2010
 
#endif
2011
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnce_ah__
2012
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
2013
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
2014
 
#include "PragmaOnceUnitState.ah"
2015
 
#endif
2016
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnce_ah__
2017
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_PragmaOnce_ah__
 
2369
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2370
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2371
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2372
#include "PragmaOnceUnitState.ah"
 
2373
#endif
 
2374
#endif
 
2375
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnce_ah__
 
2376
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2377
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnceUnitState_ah__
 
2378
#include "PragmaOnceUnitState.ah"
 
2379
#endif
 
2380
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnce_ah__
 
2381
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_PragmaOnce_ah__
2018
2382
#include "PragmaOnce.ah"
2019
2383
#endif
2020
2384
#endif
2021
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_TraceSyntax_ah__
2022
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_TraceSyntax_ah__
2023
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_TraceSyntax_ah__
 
2385
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_TraceSyntax_ah__
 
2386
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_TraceSyntax_ah__
 
2387
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_TraceSyntax_ah__
2024
2388
#include "TraceSyntax.ah"
2025
2389
#endif
2026
2390
#endif
2027
 
#ifdef __ac_need__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
2028
 
#ifndef __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
2029
 
#define __ac_have__var_tmp_aspectc4343_debian_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
 
2391
#ifdef __ac_need__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
 
2392
#ifndef __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
 
2393
#define __ac_have__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_aspects_CMatchSyntax_ah__
2030
2394
#include "CMatchSyntax.ah"
2031
2395
#endif
2032
2396
#endif
2033
 
#undef __ac_FIRST__var_tmp_aspectc4343_debian_Puma_gen45release_step1__
2034
 
#undef __ac_FIRST_FILE__var_tmp_aspectc4343_debian_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
2035
 
#endif // __ac_FIRST_FILE__var_tmp_aspectc4343_debian_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
 
2397
#undef __ac_FIRST__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1__
 
2398
#undef __ac_FIRST_FILE__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__
 
2399
#endif // __ac_FIRST_FILE__home_inf4_tartler_src_aspectc4343_upstream_Puma_gen45release_step1_inc_Puma_PreTreeNodes_h__