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, Set_kind=7, ListComp_kind=8,
 189                   SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11,
 190                   Yield_kind=12, Compare_kind=13, Call_kind=14, Repr_kind=15,
 191                   Num_kind=16, Str_kind=17, Attribute_kind=18,
 192                   Subscript_kind=19, Name_kind=20, List_kind=21, Tuple_kind=22};
 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                         asdl_seq *elts;
 230                 } Set;
 231
 232                 struct {
 233                         expr_ty elt;
 234                         asdl_seq *generators;
 235                 } ListComp;
 236
 237                 struct {
 238                         expr_ty elt;
 239                         asdl_seq *generators;
 240                 } SetComp;
 241
 242                 struct {
 243                         expr_ty key;
 244                         expr_ty value;
 245                         asdl_seq *generators;
 246                 } DictComp;
 247
 248                 struct {
 249                         expr_ty elt;
 250                         asdl_seq *generators;
 251                 } GeneratorExp;
 252
 253                 struct {
 254                         expr_ty value;
 255                 } Yield;
 256
 257                 struct {
 258                         expr_ty left;
 259                         asdl_int_seq *ops;
 260                         asdl_seq *comparators;
 261                 } Compare;
 262
 263                 struct {
 264                         expr_ty func;
 265                         asdl_seq *args;
 266                         asdl_seq *keywords;
 267                         expr_ty starargs;
 268                         expr_ty kwargs;
 269                 } Call;
 270
 271                 struct {
 272                         expr_ty value;
 273                 } Repr;
 274
 275                 struct {
 276                         object n;
 277                 } Num;
 278
 279                 struct {
 280                         string s;
 281                 } Str;
 282
 283                 struct {
 284                         expr_ty value;
 285                         identifier attr;
 286                         expr_context_ty ctx;
 287                 } Attribute;
 288
 289                 struct {
 290                         expr_ty value;
 291                         slice_ty slice;
 292                         expr_context_ty ctx;
 293                 } Subscript;
 294
 295                 struct {
 296                         identifier id;
 297                         expr_context_ty ctx;
 298                 } Name;
 299
 300                 struct {
 301                         asdl_seq *elts;
 302                         expr_context_ty ctx;
 303                 } List;
 304
 305                 struct {
 306                         asdl_seq *elts;
 307                         expr_context_ty ctx;
 308                 } Tuple;
 309
 310         } v;
 311         int lineno;
 312         int col_offset;
 313 };
 314
 315 enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4};
 316 struct _slice {
 317         enum _slice_kind kind;
 318         union {
 319                 struct {
 320                         expr_ty lower;
 321                         expr_ty upper;
 322                         expr_ty step;
 323                 } Slice;
 324
 325                 struct {
 326                         asdl_seq *dims;
 327                 } ExtSlice;
 328
 329                 struct {
 330                         expr_ty value;
 331                 } Index;
 332
 333         } v;
 334 };
 335
 336 struct _comprehension {
 337         expr_ty target;
 338         expr_ty iter;
 339         asdl_seq *ifs;
 340 };
 341
 342 enum _excepthandler_kind {ExceptHandler_kind=1};
 343 struct _excepthandler {
 344         enum _excepthandler_kind kind;
 345         union {
 346                 struct {
 347                         expr_ty type;
 348                         expr_ty name;
 349                         asdl_seq *body;
 350                 } ExceptHandler;
 351
 352         } v;
 353         int lineno;
 354         int col_offset;
 355 };
 356
 357 struct _arguments {
 358         asdl_seq *args;
 359         identifier vararg;
 360         identifier kwarg;
 361         asdl_seq *defaults;
 362 };
 363
 364 struct _keyword {
 365         identifier arg;
 366         expr_ty value;
 367 };
 368
 369 struct _alias {
 370         identifier name;
 371         identifier asname;
 372 };
 373
 374
 375 #define Module(a0, a1) _Py_Module(a0, a1)
 376 mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
 377 #define Interactive(a0, a1) _Py_Interactive(a0, a1)
 378 mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
 379 #define Expression(a0, a1) _Py_Expression(a0, a1)
 380 mod_ty _Py_Expression(expr_ty body, PyArena *arena);
 381 #define Suite(a0, a1) _Py_Suite(a0, a1)
 382 mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
 383 #define FunctionDef(a0, a1, a2, a3, a4, a5, a6) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6)
 384 stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
 385                         asdl_seq * decorator_list, int lineno, int col_offset,
 386                         PyArena *arena);
 387 #define ClassDef(a0, a1, a2, a3, a4, a5, a6) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6)
 388 stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body,
 389                      asdl_seq * decorator_list, int lineno, int col_offset,
 390                      PyArena *arena);
 391 #define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
 392 stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
 393 #define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
 394 stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
 395                    *arena);
 396 #define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
 397 stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
 398                    col_offset, PyArena *arena);
 399 #define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
 400 stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
 401                       lineno, int col_offset, PyArena *arena);
 402 #define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
 403 stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
 404                   col_offset, PyArena *arena);
 405 #define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
 406 stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
 407                 orelse, int lineno, int col_offset, PyArena *arena);
 408 #define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
 409 stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
 410                   int col_offset, PyArena *arena);
 411 #define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
 412 stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
 413                int col_offset, PyArena *arena);
 414 #define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
 415 stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
 416                  int lineno, int col_offset, PyArena *arena);
 417 #define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
 418 stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
 419                   col_offset, PyArena *arena);
 420 #define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
 421 stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
 422                       int lineno, int col_offset, PyArena *arena);
 423 #define TryFinally(a0, a1, a2, a3, a4) _Py_TryFinally(a0, a1, a2, a3, a4)
 424 stmt_ty _Py_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int
 425                        col_offset, PyArena *arena);
 426 #define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
 427 stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
 428                    PyArena *arena);
 429 #define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
 430 stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
 431                    *arena);
 432 #define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
 433 stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
 434                        lineno, int col_offset, PyArena *arena);
 435 #define Exec(a0, a1, a2, a3, a4, a5) _Py_Exec(a0, a1, a2, a3, a4, a5)
 436 stmt_ty _Py_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int
 437                  col_offset, PyArena *arena);
 438 #define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
 439 stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
 440                    *arena);
 441 #define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
 442 stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
 443 #define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
 444 stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
 445 #define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
 446 stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
 447 #define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
 448 stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
 449 #define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
 450 expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
 451                    PyArena *arena);
 452 #define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
 453 expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
 454                   col_offset, PyArena *arena);
 455 #define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
 456 expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
 457                     PyArena *arena);
 458 #define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
 459 expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
 460                    PyArena *arena);
 461 #define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
 462 expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
 463                   col_offset, PyArena *arena);
 464 #define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
 465 expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
 466                  col_offset, PyArena *arena);
 467 #define Set(a0, a1, a2, a3) _Py_Set(a0, a1, a2, a3)
 468 expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena);
 469 #define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
 470 expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
 471                      col_offset, PyArena *arena);
 472 #define SetComp(a0, a1, a2, a3, a4) _Py_SetComp(a0, a1, a2, a3, a4)
 473 expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
 474                     col_offset, PyArena *arena);
 475 #define DictComp(a0, a1, a2, a3, a4, a5) _Py_DictComp(a0, a1, a2, a3, a4, a5)
 476 expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
 477                      lineno, int col_offset, PyArena *arena);
 478 #define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
 479 expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
 480                          col_offset, PyArena *arena);
 481 #define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
 482 expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
 483 #define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
 484 expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
 485                     int lineno, int col_offset, PyArena *arena);
 486 #define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
 487 expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty
 488                  starargs, expr_ty kwargs, int lineno, int col_offset, PyArena
 489                  *arena);
 490 #define Repr(a0, a1, a2, a3) _Py_Repr(a0, a1, a2, a3)
 491 expr_ty _Py_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena);
 492 #define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
 493 expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
 494 #define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
 495 expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
 496 #define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
 497 expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
 498                       lineno, int col_offset, PyArena *arena);
 499 #define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
 500 expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
 501                       lineno, int col_offset, PyArena *arena);
 502 #define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
 503 expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
 504                  col_offset, PyArena *arena);
 505 #define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
 506 expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
 507                  col_offset, PyArena *arena);
 508 #define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
 509 expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
 510                   col_offset, PyArena *arena);
 511 #define Ellipsis(a0) _Py_Ellipsis(a0)
 512 slice_ty _Py_Ellipsis(PyArena *arena);
 513 #define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
 514 slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
 515 #define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
 516 slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
 517 #define Index(a0, a1) _Py_Index(a0, a1)
 518 slice_ty _Py_Index(expr_ty value, PyArena *arena);
 519 #define comprehension(a0, a1, a2, a3) _Py_comprehension(a0, a1, a2, a3)
 520 comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
 521                                    ifs, PyArena *arena);
 522 #define ExceptHandler(a0, a1, a2, a3, a4, a5) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5)
 523 excepthandler_ty _Py_ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body,
 524                                    int lineno, int col_offset, PyArena *arena);
 525 #define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4)
 526 arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier
 527                            kwarg, asdl_seq * defaults, PyArena *arena);
 528 #define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
 529 keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
 530 #define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
 531 alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
 532
 533 PyObject* PyAST_mod2obj(mod_ty t);
 534 mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode);
 535 int PyAST_Check(PyObject* obj);