← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Include/Python-ast.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Include/Python-ast.h
 
1
/* File automatically generated by Parser/asdl_c.py. */
 
2
 
 
3
#include "asdl.h"
 
4
 
 
5
typedef struct _mod *mod_ty;
 
6
 
 
7
typedef struct _stmt *stmt_ty;
 
8
 
 
9
typedef struct _expr *expr_ty;
 
10
 
 
11
typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5,
 
12
                             Param=6 } expr_context_ty;
 
13
 
 
14
typedef struct _slice *slice_ty;
 
15
 
 
16
typedef enum _boolop { And=1, Or=2 } boolop_ty;
 
17
 
 
18
typedef enum _operator { Add=1, Sub=2, Mult=3, Div=4, Mod=5, Pow=6, LShift=7,
 
19
                         RShift=8, BitOr=9, BitXor=10, BitAnd=11, FloorDiv=12 }
 
20
                         operator_ty;
 
21
 
 
22
typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
 
23
 
 
24
typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
 
25
                      In=9, NotIn=10 } cmpop_ty;
 
26
 
 
27
typedef struct _comprehension *comprehension_ty;
 
28
 
 
29
typedef struct _excepthandler *excepthandler_ty;
 
30
 
 
31
typedef struct _arguments *arguments_ty;
 
32
 
 
33
typedef struct _keyword *keyword_ty;
 
34
 
 
35
typedef struct _alias *alias_ty;
 
36
 
 
37
 
 
38
enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
 
39
                 Suite_kind=4};
 
40
struct _mod {
 
41
        enum _mod_kind kind;
 
42
        union {
 
43
                struct {
 
44
                        asdl_seq *body;
 
45
                } Module;
 
46
                
 
47
                struct {
 
48
                        asdl_seq *body;
 
49
                } Interactive;
 
50
                
 
51
                struct {
 
52
                        expr_ty body;
 
53
                } Expression;
 
54
                
 
55
                struct {
 
56
                        asdl_seq *body;
 
57
                } Suite;
 
58
                
 
59
        } v;
 
60
};
 
61
 
 
62
enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
 
63
                  Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7,
 
64
                  For_kind=8, While_kind=9, If_kind=10, With_kind=11,
 
65
                  Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14,
 
66
                  Assert_kind=15, Import_kind=16, ImportFrom_kind=17,
 
67
                  Exec_kind=18, Global_kind=19, Expr_kind=20, Pass_kind=21,
 
68
                  Break_kind=22, Continue_kind=23};
 
69
struct _stmt {
 
70
        enum _stmt_kind kind;
 
71
        union {
 
72
                struct {
 
73
                        identifier name;
 
74
                        arguments_ty args;
 
75
                        asdl_seq *body;
 
76
                        asdl_seq *decorator_list;
 
77
                } FunctionDef;
 
78
                
 
79
                struct {
 
80
                        identifier name;
 
81
                        asdl_seq *bases;
 
82
                        asdl_seq *body;
 
83
                        asdl_seq *decorator_list;
 
84
                } ClassDef;
 
85
                
 
86
                struct {
 
87
                        expr_ty value;
 
88
                } Return;
 
89
                
 
90
                struct {
 
91
                        asdl_seq *targets;
 
92
                } Delete;
 
93
                
 
94
                struct {
 
95
                        asdl_seq *targets;
 
96
                        expr_ty value;
 
97
                } Assign;
 
98
                
 
99
                struct {
 
100
                        expr_ty target;
 
101
                        operator_ty op;
 
102
                        expr_ty value;
 
103
                } AugAssign;
 
104
                
 
105
                struct {
 
106
                        expr_ty dest;
 
107
                        asdl_seq *values;
 
108
                        bool nl;
 
109
                } Print;
 
110
                
 
111
                struct {
 
112
                        expr_ty target;
 
113
                        expr_ty iter;
 
114
                        asdl_seq *body;
 
115
                        asdl_seq *orelse;
 
116
                } For;
 
117
                
 
118
                struct {
 
119
                        expr_ty test;
 
120
                        asdl_seq *body;
 
121
                        asdl_seq *orelse;
 
122
                } While;
 
123
                
 
124
                struct {
 
125
                        expr_ty test;
 
126
                        asdl_seq *body;
 
127
                        asdl_seq *orelse;
 
128
                } If;
 
129
                
 
130
                struct {
 
131
                        expr_ty context_expr;
 
132
                        expr_ty optional_vars;
 
133
                        asdl_seq *body;
 
134
                } With;
 
135
                
 
136
                struct {
 
137
                        expr_ty type;
 
138
                        expr_ty inst;
 
139
                        expr_ty tback;
 
140
                } Raise;
 
141
                
 
142
                struct {
 
143
                        asdl_seq *body;
 
144
                        asdl_seq *handlers;
 
145
                        asdl_seq *orelse;
 
146
                } TryExcept;
 
147
                
 
148
                struct {
 
149
                        asdl_seq *body;
 
150
                        asdl_seq *finalbody;
 
151
                } TryFinally;
 
152
                
 
153
                struct {
 
154
                        expr_ty test;
 
155
                        expr_ty msg;
 
156
                } Assert;
 
157
                
 
158
                struct {
 
159
                        asdl_seq *names;
 
160
                } Import;
 
161
                
 
162
                struct {
 
163
                        identifier module;
 
164
                        asdl_seq *names;
 
165
                        int level;
 
166
                } ImportFrom;
 
167
                
 
168
                struct {
 
169
                        expr_ty body;
 
170
                        expr_ty globals;
 
171
                        expr_ty locals;
 
172
                } Exec;
 
173
                
 
174
                struct {
 
175
                        asdl_seq *names;
 
176
                } Global;
 
177
                
 
178
                struct {
 
179
                        expr_ty value;
 
180
                } Expr;
 
181
                
 
182
        } v;
 
183
        int lineno;
 
184
        int col_offset;
 
185
};
 
186
 
 
187
enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
 
188
                  IfExp_kind=5, Dict_kind=6, ListComp_kind=7,
 
189
                  GeneratorExp_kind=8, Yield_kind=9, Compare_kind=10,
 
190
                  Call_kind=11, Repr_kind=12, Num_kind=13, Str_kind=14,
 
191
                  Attribute_kind=15, Subscript_kind=16, Name_kind=17,
 
192
                  List_kind=18, Tuple_kind=19};
 
193
struct _expr {
 
194
        enum _expr_kind kind;
 
195
        union {
 
196
                struct {
 
197
                        boolop_ty op;
 
198
                        asdl_seq *values;
 
199
                } BoolOp;
 
200
                
 
201
                struct {
 
202
                        expr_ty left;
 
203
                        operator_ty op;
 
204
                        expr_ty right;
 
205
                } BinOp;
 
206
                
 
207
                struct {
 
208
                        unaryop_ty op;
 
209
                        expr_ty operand;
 
210
                } UnaryOp;
 
211
                
 
212
                struct {
 
213
                        arguments_ty args;
 
214
                        expr_ty body;
 
215
                } Lambda;
 
216
                
 
217
                struct {
 
218
                        expr_ty test;
 
219
                        expr_ty body;
 
220
                        expr_ty orelse;
 
221
                } IfExp;
 
222
                
 
223
                struct {
 
224
                        asdl_seq *keys;
 
225
                        asdl_seq *values;
 
226
                } Dict;
 
227
                
 
228
                struct {
 
229
                        expr_ty elt;
 
230
                        asdl_seq *generators;
 
231
                } ListComp;
 
232
                
 
233
                struct {
 
234
                        expr_ty elt;
 
235
                        asdl_seq *generators;
 
236
                } GeneratorExp;
 
237
                
 
238
                struct {
 
239
                        expr_ty value;
 
240
                } Yield;
 
241
                
 
242
                struct {
 
243
                        expr_ty left;
 
244
                        asdl_int_seq *ops;
 
245
                        asdl_seq *comparators;
 
246
                } Compare;
 
247
                
 
248
                struct {
 
249
                        expr_ty func;
 
250
                        asdl_seq *args;
 
251
                        asdl_seq *keywords;
 
252
                        expr_ty starargs;
 
253
                        expr_ty kwargs;
 
254
                } Call;
 
255
                
 
256
                struct {
 
257
                        expr_ty value;
 
258
                } Repr;
 
259
                
 
260
                struct {
 
261
                        object n;
 
262
                } Num;
 
263
                
 
264
                struct {
 
265
                        string s;
 
266
                } Str;
 
267
                
 
268
                struct {
 
269
                        expr_ty value;
 
270
                        identifier attr;
 
271
                        expr_context_ty ctx;
 
272
                } Attribute;
 
273
                
 
274
                struct {
 
275
                        expr_ty value;
 
276
                        slice_ty slice;
 
277
                        expr_context_ty ctx;
 
278
                } Subscript;
 
279
                
 
280
                struct {
 
281
                        identifier id;
 
282
                        expr_context_ty ctx;
 
283
                } Name;
 
284
                
 
285
                struct {
 
286
                        asdl_seq *elts;
 
287
                        expr_context_ty ctx;
 
288
                } List;
 
289
                
 
290
                struct {
 
291
                        asdl_seq *elts;
 
292
                        expr_context_ty ctx;
 
293
                } Tuple;
 
294
                
 
295
        } v;
 
296
        int lineno;
 
297
        int col_offset;
 
298
};
 
299
 
 
300
enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4};
 
301
struct _slice {
 
302
        enum _slice_kind kind;
 
303
        union {
 
304
                struct {
 
305
                        expr_ty lower;
 
306
                        expr_ty upper;
 
307
                        expr_ty step;
 
308
                } Slice;
 
309
                
 
310
                struct {
 
311
                        asdl_seq *dims;
 
312
                } ExtSlice;
 
313
                
 
314
                struct {
 
315
                        expr_ty value;
 
316
                } Index;
 
317
                
 
318
        } v;
 
319
};
 
320
 
 
321
struct _comprehension {
 
322
        expr_ty target;
 
323
        expr_ty iter;
 
324
        asdl_seq *ifs;
 
325
};
 
326
 
 
327
enum _excepthandler_kind {ExceptHandler_kind=1};
 
328
struct _excepthandler {
 
329
        enum _excepthandler_kind kind;
 
330
        union {
 
331
                struct {
 
332
                        expr_ty type;
 
333
                        expr_ty name;
 
334
                        asdl_seq *body;
 
335
                } ExceptHandler;
 
336
                
 
337
        } v;
 
338
        int lineno;
 
339
        int col_offset;
 
340
};
 
341
 
 
342
struct _arguments {
 
343
        asdl_seq *args;
 
344
        identifier vararg;
 
345
        identifier kwarg;
 
346
        asdl_seq *defaults;
 
347
};
 
348
 
 
349
struct _keyword {
 
350
        identifier arg;
 
351
        expr_ty value;
 
352
};
 
353
 
 
354
struct _alias {
 
355
        identifier name;
 
356
        identifier asname;
 
357
};
 
358
 
 
359
 
 
360
#define Module(a0, a1) _Py_Module(a0, a1)
 
361
mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
 
362
#define Interactive(a0, a1) _Py_Interactive(a0, a1)
 
363
mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
 
364
#define Expression(a0, a1) _Py_Expression(a0, a1)
 
365
mod_ty _Py_Expression(expr_ty body, PyArena *arena);
 
366
#define Suite(a0, a1) _Py_Suite(a0, a1)
 
367
mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
 
368
#define FunctionDef(a0, a1, a2, a3, a4, a5, a6) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6)
 
369
stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
 
370
                        asdl_seq * decorator_list, int lineno, int col_offset,
 
371
                        PyArena *arena);
 
372
#define ClassDef(a0, a1, a2, a3, a4, a5, a6) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6)
 
373
stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body,
 
374
                     asdl_seq * decorator_list, int lineno, int col_offset,
 
375
                     PyArena *arena);
 
376
#define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
 
377
stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
 
378
#define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
 
379
stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
 
380
                   *arena);
 
381
#define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
 
382
stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
 
383
                   col_offset, PyArena *arena);
 
384
#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
 
385
stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
 
386
                      lineno, int col_offset, PyArena *arena);
 
387
#define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
 
388
stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
 
389
                  col_offset, PyArena *arena);
 
390
#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
 
391
stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
 
392
                orelse, int lineno, int col_offset, PyArena *arena);
 
393
#define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
 
394
stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
 
395
                  int col_offset, PyArena *arena);
 
396
#define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
 
397
stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
 
398
               int col_offset, PyArena *arena);
 
399
#define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
 
400
stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
 
401
                 int lineno, int col_offset, PyArena *arena);
 
402
#define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
 
403
stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
 
404
                  col_offset, PyArena *arena);
 
405
#define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
 
406
stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
 
407
                      int lineno, int col_offset, PyArena *arena);
 
408
#define TryFinally(a0, a1, a2, a3, a4) _Py_TryFinally(a0, a1, a2, a3, a4)
 
409
stmt_ty _Py_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int
 
410
                       col_offset, PyArena *arena);
 
411
#define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
 
412
stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
 
413
                   PyArena *arena);
 
414
#define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
 
415
stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
 
416
                   *arena);
 
417
#define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
 
418
stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
 
419
                       lineno, int col_offset, PyArena *arena);
 
420
#define Exec(a0, a1, a2, a3, a4, a5) _Py_Exec(a0, a1, a2, a3, a4, a5)
 
421
stmt_ty _Py_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int
 
422
                 col_offset, PyArena *arena);
 
423
#define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
 
424
stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
 
425
                   *arena);
 
426
#define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
 
427
stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
 
428
#define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
 
429
stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
 
430
#define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
 
431
stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
 
432
#define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
 
433
stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
 
434
#define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
 
435
expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
 
436
                   PyArena *arena);
 
437
#define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
 
438
expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
 
439
                  col_offset, PyArena *arena);
 
440
#define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
 
441
expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
 
442
                    PyArena *arena);
 
443
#define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
 
444
expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
 
445
                   PyArena *arena);
 
446
#define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
 
447
expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
 
448
                  col_offset, PyArena *arena);
 
449
#define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
 
450
expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
 
451
                 col_offset, PyArena *arena);
 
452
#define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
 
453
expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
 
454
                     col_offset, PyArena *arena);
 
455
#define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
 
456
expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
 
457
                         col_offset, PyArena *arena);
 
458
#define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
 
459
expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
 
460
#define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
 
461
expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
 
462
                    int lineno, int col_offset, PyArena *arena);
 
463
#define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
 
464
expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty
 
465
                 starargs, expr_ty kwargs, int lineno, int col_offset, PyArena
 
466
                 *arena);
 
467
#define Repr(a0, a1, a2, a3) _Py_Repr(a0, a1, a2, a3)
 
468
expr_ty _Py_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena);
 
469
#define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
 
470
expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
 
471
#define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
 
472
expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
 
473
#define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
 
474
expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
 
475
                      lineno, int col_offset, PyArena *arena);
 
476
#define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
 
477
expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
 
478
                      lineno, int col_offset, PyArena *arena);
 
479
#define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
 
480
expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
 
481
                 col_offset, PyArena *arena);
 
482
#define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
 
483
expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
 
484
                 col_offset, PyArena *arena);
 
485
#define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
 
486
expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
 
487
                  col_offset, PyArena *arena);
 
488
#define Ellipsis(a0) _Py_Ellipsis(a0)
 
489
slice_ty _Py_Ellipsis(PyArena *arena);
 
490
#define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
 
491
slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
 
492
#define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
 
493
slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
 
494
#define Index(a0, a1) _Py_Index(a0, a1)
 
495
slice_ty _Py_Index(expr_ty value, PyArena *arena);
 
496
#define comprehension(a0, a1, a2, a3) _Py_comprehension(a0, a1, a2, a3)
 
497
comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
 
498
                                   ifs, PyArena *arena);
 
499
#define ExceptHandler(a0, a1, a2, a3, a4, a5) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5)
 
500
excepthandler_ty _Py_ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body,
 
501
                                   int lineno, int col_offset, PyArena *arena);
 
502
#define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4)
 
503
arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier
 
504
                           kwarg, asdl_seq * defaults, PyArena *arena);
 
505
#define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
 
506
keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
 
507
#define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
 
508
alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
 
509
 
 
510
PyObject* PyAST_mod2obj(mod_ty t);
 
511
mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode);
 
512
int PyAST_Check(PyObject* obj);