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);