typed-ast-1.1.0/0000755€Tøžæ€2›s®0000000000013133476735014734 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/0000755€Tøžæ€2›s®0000000000013133476735015674 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/Custom/0000755€Tøžæ€2›s®0000000000013133476735017146 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/Custom/typed_ast.c0000644€Tøžæ€2›s®0000002126213133474673021310 0ustar ddfisher00000000000000#include "Python.h" #include "Python-ast.h" #include "compile.h" #include "node.h" #include "grammar.h" #include "token.h" #include "ast.h" #include "parsetok.h" #include "errcode.h" extern grammar _Ta27Parser_Grammar; /* from graminit.c */ // from Python/bltinmodule.c static const char * source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompilerFlags *cf, PyObject **cmd_copy) { const char *str; Py_ssize_t size; Py_buffer view; *cmd_copy = NULL; if (PyUnicode_Check(cmd)) { cf->cf_flags |= PyCF_IGNORE_COOKIE; str = PyUnicode_AsUTF8AndSize(cmd, &size); if (str == NULL) return NULL; } else if (PyBytes_Check(cmd)) { str = PyBytes_AS_STRING(cmd); size = PyBytes_GET_SIZE(cmd); } else if (PyByteArray_Check(cmd)) { str = PyByteArray_AS_STRING(cmd); size = PyByteArray_GET_SIZE(cmd); } else if (PyObject_GetBuffer(cmd, &view, PyBUF_SIMPLE) == 0) { /* Copy to NUL-terminated buffer. */ *cmd_copy = PyBytes_FromStringAndSize( (const char *)view.buf, view.len); PyBuffer_Release(&view); if (*cmd_copy == NULL) { return NULL; } str = PyBytes_AS_STRING(*cmd_copy); size = PyBytes_GET_SIZE(*cmd_copy); } else { PyErr_Format(PyExc_TypeError, "%s() arg 1 must be a %s object", funcname, what); return NULL; } if (strlen(str) != (size_t)size) { PyErr_SetString(PyExc_ValueError, "source code string cannot contain null bytes"); Py_CLEAR(*cmd_copy); return NULL; } return str; } // from Python/pythonrun.c /* compute parser flags based on compiler flags */ static int PARSER_FLAGS(PyCompilerFlags *flags) { int parser_flags = 0; if (!flags) return 0; if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT) parser_flags |= PyPARSE_DONT_IMPLY_DEDENT; if (flags->cf_flags & PyCF_IGNORE_COOKIE) parser_flags |= PyPARSE_IGNORE_COOKIE; return parser_flags; } // from Python/pythonrun.c /* Set the error appropriate to the given input error code (see errcode.h) */ static void err_input(perrdetail *err) { PyObject *v, *w, *errtype, *errtext; PyObject *msg_obj = NULL; char *msg = NULL; int offset = err->offset; errtype = PyExc_SyntaxError; switch (err->error) { case E_ERROR: return; case E_SYNTAX: errtype = PyExc_IndentationError; if (err->expected == INDENT) msg = "expected an indented block"; else if (err->token == INDENT) msg = "unexpected indent"; else if (err->token == DEDENT) msg = "unexpected unindent"; else { errtype = PyExc_SyntaxError; if (err->token == TYPE_COMMENT) msg = "misplaced type annotation"; else msg = "invalid syntax"; } break; case E_TOKEN: msg = "invalid token"; break; case E_EOFS: msg = "EOF while scanning triple-quoted string literal"; break; case E_EOLS: msg = "EOL while scanning string literal"; break; case E_INTR: if (!PyErr_Occurred()) PyErr_SetNone(PyExc_KeyboardInterrupt); goto cleanup; case E_NOMEM: PyErr_NoMemory(); goto cleanup; case E_EOF: msg = "unexpected EOF while parsing"; break; case E_TABSPACE: errtype = PyExc_TabError; msg = "inconsistent use of tabs and spaces in indentation"; break; case E_OVERFLOW: msg = "expression too long"; break; case E_DEDENT: errtype = PyExc_IndentationError; msg = "unindent does not match any outer indentation level"; break; case E_TOODEEP: errtype = PyExc_IndentationError; msg = "too many levels of indentation"; break; case E_DECODE: { PyObject *type, *value, *tb; PyErr_Fetch(&type, &value, &tb); msg = "unknown decode error"; if (value != NULL) msg_obj = PyObject_Str(value); Py_XDECREF(type); Py_XDECREF(value); Py_XDECREF(tb); break; } case E_LINECONT: msg = "unexpected character after line continuation character"; break; default: fprintf(stderr, "error=%d\n", err->error); msg = "unknown parsing error"; break; } /* err->text may not be UTF-8 in case of decoding errors. Explicitly convert to an object. */ if (!err->text) { errtext = Py_None; Py_INCREF(Py_None); } else { errtext = PyUnicode_DecodeUTF8(err->text, err->offset, "replace"); if (errtext != NULL) { Py_ssize_t len = strlen(err->text); offset = (int)PyUnicode_GET_LENGTH(errtext); if (len != err->offset) { Py_DECREF(errtext); errtext = PyUnicode_DecodeUTF8(err->text, len, "replace"); } } } v = Py_BuildValue("(OiiN)", err->filename, err->lineno, offset, errtext); if (v != NULL) { if (msg_obj) w = Py_BuildValue("(OO)", msg_obj, v); else w = Py_BuildValue("(sO)", msg, v); } else w = NULL; Py_XDECREF(v); PyErr_SetObject(errtype, w); Py_XDECREF(w); cleanup: Py_XDECREF(msg_obj); if (err->text != NULL) { PyObject_FREE(err->text); err->text = NULL; } } // from Python/pythonrun.c static void err_free(perrdetail *err) { Py_CLEAR(err->filename); } // copy of PyParser_ASTFromStringObject in Python/pythonrun.c /* Preferred access to parser is through AST. */ static mod_ty string_object_to_c_ast(const char *s, PyObject *filename, int start, PyCompilerFlags *flags, PyArena *arena) { mod_ty mod; PyCompilerFlags localflags; perrdetail err; int iflags = PARSER_FLAGS(flags); node *n = Ta27Parser_ParseStringObject(s, filename, &_Ta27Parser_Grammar, start, &err, &iflags); if (flags == NULL) { localflags.cf_flags = 0; flags = &localflags; } if (n) { flags->cf_flags |= iflags & PyCF_MASK; mod = Ta27AST_FromNode(n, flags, PyUnicode_AsUTF8(filename), arena); Ta27Node_Free(n); } else { err_input(&err); mod = NULL; } err_free(&err); return mod; } // adapted from Py_CompileStringObject in Python/pythonrun.c static PyObject * string_object_to_py_ast(const char *str, PyObject *filename, int start, PyCompilerFlags *flags) { mod_ty mod; PyObject *result; PyArena *arena = PyArena_New(); if (arena == NULL) return NULL; mod = string_object_to_c_ast(str, filename, start, flags, arena); if (mod == NULL) { PyArena_Free(arena); return NULL; } result = Ta27AST_mod2obj(mod); PyArena_Free(arena); return result; } // adapted from builtin_compile_impl in Python/bltinmodule.c static PyObject * ast27_parse_impl(PyObject *source, PyObject *filename, const char *mode) { PyObject *source_copy; const char *str; int compile_mode = -1; PyCompilerFlags cf; int start[] = {Py_file_input, Py_eval_input, Py_single_input /*, Py_func_type_input */}; PyObject *result; cf.cf_flags = PyCF_ONLY_AST | PyCF_SOURCE_IS_UTF8; if (strcmp(mode, "exec") == 0) compile_mode = 0; else if (strcmp(mode, "eval") == 0) compile_mode = 1; else if (strcmp(mode, "single") == 0) compile_mode = 2; else if (strcmp(mode, "func_type") == 0) compile_mode = 3; else { PyErr_SetString(PyExc_ValueError, "parse() mode must be 'exec', 'eval', 'single', for 'func_type'"); goto error; } str = source_as_string(source, "parse", "string or bytes", &cf, &source_copy); if (str == NULL) goto error; result = string_object_to_py_ast(str, filename, start[compile_mode], &cf); Py_XDECREF(source_copy); goto finally; error: result = NULL; finally: Py_DECREF(filename); return result; } // adapted from builtin_compile in Python/clinic/bltinmodule.c.h PyObject * ast27_parse(PyObject *self, PyObject *args) { PyObject *return_value = NULL; PyObject *source; PyObject *filename; const char *mode; if (PyArg_ParseTuple(args, "OO&s:parse", &source, PyUnicode_FSDecoder, &filename, &mode)) return_value = ast27_parse_impl(source, filename, mode); return return_value; } typed-ast-1.1.0/ast27/Include/0000755€Tøžæ€2›s®0000000000013133476735017257 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/Include/asdl.h0000644€Tøžæ€2›s®0000000245513050216645020347 0ustar ddfisher00000000000000#ifndef Ta27_ASDL_H #define Ta27_ASDL_H typedef PyObject * identifier; typedef PyObject * string; typedef PyObject * object; #ifndef __cplusplus typedef enum {false, true} bool; #endif /* It would be nice if the code generated by asdl_c.py was completely independent of Python, but it is a goal the requires too much work at this stage. So, for example, I'll represent identifiers as interned Python strings. */ /* XXX A sequence should be typed so that its use can be typechecked. */ typedef struct { int size; void *elements[1]; } asdl_seq; typedef struct { int size; int elements[1]; } asdl_int_seq; #if PY_MINOR_VERSION > 3 #define asdl_seq_new _Py_asdl_seq_new #define asdl_int_seq_new _Py_asdl_int_seq_new #else #define _Py_asdl_seq_new asdl_seq_new #define _Py_asdl_int_seq_new asdl_int_seq_new #endif asdl_seq *asdl_seq_new(Py_ssize_t size, PyArena *arena); asdl_int_seq *asdl_int_seq_new(Py_ssize_t size, PyArena *arena); #define asdl_seq_GET(S, I) (S)->elements[(I)] #define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size) #ifdef Py_DEBUG #define asdl_seq_SET(S, I, V) { \ int _asdl_i = (I); \ assert((S) && _asdl_i < (S)->size); \ (S)->elements[_asdl_i] = (V); \ } #else #define asdl_seq_SET(S, I, V) (S)->elements[I] = (V) #endif #endif /* !Ta27_ASDL_H */ typed-ast-1.1.0/ast27/Include/ast.h0000644€Tøžæ€2›s®0000000034213050216645020204 0ustar ddfisher00000000000000#ifndef Ta27_AST_H #define Ta27_AST_H #ifdef __cplusplus extern "C" { #endif mod_ty Ta27AST_FromNode(const node *, PyCompilerFlags *flags, const char *, PyArena *); #ifdef __cplusplus } #endif #endif /* !Ta27_AST_H */ typed-ast-1.1.0/ast27/Include/bitset.h0000644€Tøžæ€2›s®0000000143613050216645020714 0ustar ddfisher00000000000000 #ifndef Ta27_BITSET_H #define Ta27_BITSET_H #ifdef __cplusplus extern "C" { #endif /* Bitset interface */ #define BYTE char typedef BYTE *bitset; bitset newbitset(int nbits); void delbitset(bitset bs); #define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0) int addbit(bitset bs, int ibit); /* Returns 0 if already set */ int samebitset(bitset bs1, bitset bs2, int nbits); void mergebitset(bitset bs1, bitset bs2, int nbits); #define BITSPERBYTE (8*sizeof(BYTE)) #define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE) #define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE) #define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE) #define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit)) #define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE) #ifdef __cplusplus } #endif #endif /* !Ta27_BITSET_H */ typed-ast-1.1.0/ast27/Include/compile.h0000644€Tøžæ€2›s®0000000041313050216645021044 0ustar ddfisher00000000000000 #ifndef Ta27_COMPILE_H #define Ta27_COMPILE_H #include "code.h" #ifdef __cplusplus extern "C" { #endif /* Public interface */ PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(struct _mod *, const char *); #ifdef __cplusplus } #endif #endif /* !Ta27_COMPILE_H */ typed-ast-1.1.0/ast27/Include/errcode.h0000644€Tøžæ€2›s®0000000253113050216645021042 0ustar ddfisher00000000000000#ifndef Ta27_ERRCODE_H #define Ta27_ERRCODE_H #ifdef __cplusplus extern "C" { #endif /* Error codes passed around between file input, tokenizer, parser and interpreter. This is necessary so we can turn them into Python exceptions at a higher level. Note that some errors have a slightly different meaning when passed from the tokenizer to the parser than when passed from the parser to the interpreter; e.g. the parser only returns E_EOF when it hits EOF immediately, and it never returns E_OK. */ #define E_OK 10 /* No error */ #define E_EOF 11 /* End Of File */ #define E_INTR 12 /* Interrupted */ #define E_TOKEN 13 /* Bad token */ #define E_SYNTAX 14 /* Syntax error */ #define E_NOMEM 15 /* Ran out of memory */ #define E_DONE 16 /* Parsing complete */ #define E_ERROR 17 /* Execution error */ #define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */ #define E_OVERFLOW 19 /* Node had too many children */ #define E_TOODEEP 20 /* Too many indentation levels */ #define E_DEDENT 21 /* No matching outer block for dedent */ #define E_DECODE 22 /* Error in decoding into Unicode */ #define E_EOFS 23 /* EOF in triple-quoted string */ #define E_EOLS 24 /* EOL in single-quoted string */ #define E_LINECONT 25 /* Unexpected characters after a line continuation */ #ifdef __cplusplus } #endif #endif /* !Ta27_ERRCODE_H */ typed-ast-1.1.0/ast27/Include/graminit.h0000644€Tøžæ€2›s®0000000370413050216645021234 0ustar ddfisher00000000000000/* Generated by Parser/pgen */ #define single_input 256 #define file_input 257 #define eval_input 258 #define decorator 259 #define decorators 260 #define decorated 261 #define funcdef 262 #define parameters 263 #define varargslist 264 #define fpdef 265 #define fplist 266 #define stmt 267 #define simple_stmt 268 #define small_stmt 269 #define expr_stmt 270 #define augassign 271 #define print_stmt 272 #define del_stmt 273 #define pass_stmt 274 #define flow_stmt 275 #define break_stmt 276 #define continue_stmt 277 #define return_stmt 278 #define yield_stmt 279 #define raise_stmt 280 #define import_stmt 281 #define import_name 282 #define import_from 283 #define import_as_name 284 #define dotted_as_name 285 #define import_as_names 286 #define dotted_as_names 287 #define dotted_name 288 #define global_stmt 289 #define exec_stmt 290 #define assert_stmt 291 #define compound_stmt 292 #define if_stmt 293 #define while_stmt 294 #define for_stmt 295 #define try_stmt 296 #define with_stmt 297 #define with_item 298 #define except_clause 299 #define suite 300 #define testlist_safe 301 #define old_test 302 #define old_lambdef 303 #define test 304 #define or_test 305 #define and_test 306 #define not_test 307 #define comparison 308 #define comp_op 309 #define expr 310 #define xor_expr 311 #define and_expr 312 #define shift_expr 313 #define arith_expr 314 #define term 315 #define factor 316 #define power 317 #define atom 318 #define listmaker 319 #define testlist_comp 320 #define lambdef 321 #define trailer 322 #define subscriptlist 323 #define subscript 324 #define sliceop 325 #define exprlist 326 #define testlist 327 #define dictorsetmaker 328 #define classdef 329 #define arglist 330 #define argument 331 #define list_iter 332 #define list_for 333 #define list_if 334 #define comp_iter 335 #define comp_for 336 #define comp_if 337 #define testlist1 338 #define encoding_decl 339 #define yield_expr 340 #define func_type_input 341 #define func_type 342 #define typelist 343 typed-ast-1.1.0/ast27/Include/grammar.h0000644€Tøžæ€2›s®0000000376313050216645021055 0ustar ddfisher00000000000000 /* Grammar interface */ #ifndef Ta27_GRAMMAR_H #define Ta27_GRAMMAR_H #ifdef __cplusplus extern "C" { #endif #include "bitset.h" /* Sigh... */ /* A label of an arc */ typedef struct { int lb_type; char *lb_str; } label; #define EMPTY 0 /* Label number 0 is by definition the empty label */ /* A list of labels */ typedef struct { int ll_nlabels; label *ll_label; } labellist; /* An arc from one state to another */ typedef struct { short a_lbl; /* Label of this arc */ short a_arrow; /* State where this arc goes to */ } arc; /* A state in a DFA */ typedef struct { int s_narcs; arc *s_arc; /* Array of arcs */ /* Optional accelerators */ int s_lower; /* Lowest label index */ int s_upper; /* Highest label index */ int *s_accel; /* Accelerator */ int s_accept; /* Nonzero for accepting state */ } state; /* A DFA */ typedef struct { int d_type; /* Non-terminal this represents */ char *d_name; /* For printing */ int d_initial; /* Initial state */ int d_nstates; state *d_state; /* Array of states */ bitset d_first; } dfa; /* A grammar */ typedef struct { int g_ndfas; dfa *g_dfa; /* Array of DFAs */ labellist g_ll; int g_start; /* Start symbol of the grammar */ int g_accel; /* Set if accelerators present */ } grammar; /* FUNCTIONS */ grammar *newgrammar(int start); dfa *adddfa(grammar *g, int type, char *name); int addstate(dfa *d); void addarc(dfa *d, int from, int to, int lbl); dfa *Ta27Grammar_FindDFA(grammar *g, int type); int addlabel(labellist *ll, int type, char *str); int findlabel(labellist *ll, int type, char *str); char *Ta27Grammar_LabelRepr(label *lb); void translatelabels(grammar *g); void addfirstsets(grammar *g); void Ta27Grammar_AddAccelerators(grammar *g); void Ta27Grammar_RemoveAccelerators(grammar *); void printgrammar(grammar *g, FILE *fp); void printnonterminals(grammar *g, FILE *fp); #ifdef __cplusplus } #endif #endif /* !Ta27_GRAMMAR_H */ typed-ast-1.1.0/ast27/Include/node.h0000644€Tøžæ€2›s®0000000156713050216645020354 0ustar ddfisher00000000000000 /* Parse tree node interface */ #ifndef Ta27_NODE_H #define Ta27_NODE_H #ifdef __cplusplus extern "C" { #endif typedef struct _node { short n_type; char *n_str; int n_lineno; int n_col_offset; int n_nchildren; struct _node *n_child; } node; node *Ta27Node_New(int type); int Ta27Node_AddChild(node *n, int type, char *str, int lineno, int col_offset); void Ta27Node_Free(node *n); Py_ssize_t _Ta27Node_SizeOf(node *n); /* Node access functions */ #define NCH(n) ((n)->n_nchildren) #define CHILD(n, i) (&(n)->n_child[i]) #define RCHILD(n, i) (CHILD(n, NCH(n) + i)) #define TYPE(n) ((n)->n_type) #define STR(n) ((n)->n_str) /* Assert that the type of a node is what we expect */ #define REQ(n, type) assert(TYPE(n) == (type)) PyAPI_FUNC(void) PyNode_ListTree(node *); #ifdef __cplusplus } #endif #endif /* !Ta27_NODE_H */ typed-ast-1.1.0/ast27/Include/parsetok.h0000644€Tøžæ€2›s®0000000346513050216645021256 0ustar ddfisher00000000000000 /* Parser-tokenizer link interface */ #ifndef Ta27_PARSETOK_H #define Ta27_PARSETOK_H #ifdef __cplusplus extern "C" { #endif typedef struct { int error; PyObject *filename; int lineno; int offset; char *text; int token; int expected; } perrdetail; #if 0 #define PyPARSE_YIELD_IS_KEYWORD 0x0001 #endif #define PyPARSE_DONT_IMPLY_DEDENT 0x0002 #if 0 #define PyPARSE_WITH_IS_KEYWORD 0x0003 #endif #define PyPARSE_PRINT_IS_FUNCTION 0x0004 #define PyPARSE_UNICODE_LITERALS 0x0008 #define PyPARSE_IGNORE_COOKIE 0x0010 node *Ta27Parser_ParseString(const char *, grammar *, int, perrdetail *); node *Ta27Parser_ParseFile (FILE *, const char *, grammar *, int, char *, char *, perrdetail *); node *Ta27Parser_ParseStringFlags(const char *, grammar *, int, perrdetail *, int); node *Ta27Parser_ParseFileFlags(FILE *, const char *, grammar *, int, char *, char *, perrdetail *, int); node *Ta27Parser_ParseFileFlagsEx(FILE *, const char *, grammar *, int, char *, char *, perrdetail *, int *); node *Ta27Parser_ParseStringFlagsFilename(const char *, const char *, grammar *, int, perrdetail *, int); node *Ta27Parser_ParseStringFlagsFilenameEx(const char *, const char *, grammar *, int, perrdetail *, int *); node *Ta27Parser_ParseStringObject( const char *s, PyObject *filename, grammar *g, int start, perrdetail *err_ret, int *flags); /* Note that he following function is defined in pythonrun.c not parsetok.c. */ PyAPI_FUNC(void) PyParser_SetError(perrdetail *); #ifdef __cplusplus } #endif #endif /* !Ta27_PARSETOK_H */ typed-ast-1.1.0/ast27/Include/Python-ast.h0000644€Tøžæ€2›s®0000005345313050216645021476 0ustar ddfisher00000000000000/* File automatically generated by Parser/asdl_c.py. */ #include "asdl.h" typedef struct _mod *mod_ty; typedef struct _stmt *stmt_ty; typedef struct _expr *expr_ty; typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5, Param=6 } expr_context_ty; typedef struct _slice *slice_ty; typedef enum _boolop { And=1, Or=2 } boolop_ty; typedef enum _operator { Add=1, Sub=2, Mult=3, Div=4, Mod=5, Pow=6, LShift=7, RShift=8, BitOr=9, BitXor=10, BitAnd=11, FloorDiv=12 } operator_ty; typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty; typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8, In=9, NotIn=10 } cmpop_ty; typedef struct _comprehension *comprehension_ty; typedef struct _excepthandler *excepthandler_ty; typedef struct _arguments *arguments_ty; typedef struct _keyword *keyword_ty; typedef struct _alias *alias_ty; typedef struct _type_ignore *type_ignore_ty; enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, FunctionType_kind=4, Suite_kind=5}; struct _mod { enum _mod_kind kind; union { struct { asdl_seq *body; asdl_seq *type_ignores; } Module; struct { asdl_seq *body; } Interactive; struct { expr_ty body; } Expression; struct { asdl_seq *argtypes; expr_ty returns; } FunctionType; struct { asdl_seq *body; } Suite; } v; }; enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3, Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7, For_kind=8, While_kind=9, If_kind=10, With_kind=11, Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14, Assert_kind=15, Import_kind=16, ImportFrom_kind=17, Exec_kind=18, Global_kind=19, Expr_kind=20, Pass_kind=21, Break_kind=22, Continue_kind=23}; struct _stmt { enum _stmt_kind kind; union { struct { identifier name; arguments_ty args; asdl_seq *body; asdl_seq *decorator_list; string type_comment; } FunctionDef; struct { identifier name; asdl_seq *bases; asdl_seq *body; asdl_seq *decorator_list; } ClassDef; struct { expr_ty value; } Return; struct { asdl_seq *targets; } Delete; struct { asdl_seq *targets; expr_ty value; string type_comment; } Assign; struct { expr_ty target; operator_ty op; expr_ty value; } AugAssign; struct { expr_ty dest; asdl_seq *values; bool nl; } Print; struct { expr_ty target; expr_ty iter; asdl_seq *body; asdl_seq *orelse; string type_comment; } For; struct { expr_ty test; asdl_seq *body; asdl_seq *orelse; } While; struct { expr_ty test; asdl_seq *body; asdl_seq *orelse; } If; struct { expr_ty context_expr; expr_ty optional_vars; asdl_seq *body; string type_comment; } With; struct { expr_ty type; expr_ty inst; expr_ty tback; } Raise; struct { asdl_seq *body; asdl_seq *handlers; asdl_seq *orelse; } TryExcept; struct { asdl_seq *body; asdl_seq *finalbody; } TryFinally; struct { expr_ty test; expr_ty msg; } Assert; struct { asdl_seq *names; } Import; struct { identifier module; asdl_seq *names; int level; } ImportFrom; struct { expr_ty body; expr_ty globals; expr_ty locals; } Exec; struct { asdl_seq *names; } Global; struct { expr_ty value; } Expr; } v; int lineno; int col_offset; }; enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4, IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8, SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11, Yield_kind=12, Compare_kind=13, Call_kind=14, Repr_kind=15, Num_kind=16, Str_kind=17, Attribute_kind=18, Subscript_kind=19, Name_kind=20, List_kind=21, Tuple_kind=22}; struct _expr { enum _expr_kind kind; union { struct { boolop_ty op; asdl_seq *values; } BoolOp; struct { expr_ty left; operator_ty op; expr_ty right; } BinOp; struct { unaryop_ty op; expr_ty operand; } UnaryOp; struct { arguments_ty args; expr_ty body; } Lambda; struct { expr_ty test; expr_ty body; expr_ty orelse; } IfExp; struct { asdl_seq *keys; asdl_seq *values; } Dict; struct { asdl_seq *elts; } Set; struct { expr_ty elt; asdl_seq *generators; } ListComp; struct { expr_ty elt; asdl_seq *generators; } SetComp; struct { expr_ty key; expr_ty value; asdl_seq *generators; } DictComp; struct { expr_ty elt; asdl_seq *generators; } GeneratorExp; struct { expr_ty value; } Yield; struct { expr_ty left; asdl_int_seq *ops; asdl_seq *comparators; } Compare; struct { expr_ty func; asdl_seq *args; asdl_seq *keywords; expr_ty starargs; expr_ty kwargs; } Call; struct { expr_ty value; } Repr; struct { object n; } Num; struct { string s; int has_b; } Str; struct { expr_ty value; identifier attr; expr_context_ty ctx; } Attribute; struct { expr_ty value; slice_ty slice; expr_context_ty ctx; } Subscript; struct { identifier id; expr_context_ty ctx; } Name; struct { asdl_seq *elts; expr_context_ty ctx; } List; struct { asdl_seq *elts; expr_context_ty ctx; } Tuple; } v; int lineno; int col_offset; }; enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4}; struct _slice { enum _slice_kind kind; union { struct { expr_ty lower; expr_ty upper; expr_ty step; } Slice; struct { asdl_seq *dims; } ExtSlice; struct { expr_ty value; } Index; } v; }; struct _comprehension { expr_ty target; expr_ty iter; asdl_seq *ifs; }; enum _excepthandler_kind {ExceptHandler_kind=1}; struct _excepthandler { enum _excepthandler_kind kind; union { struct { expr_ty type; expr_ty name; asdl_seq *body; } ExceptHandler; } v; int lineno; int col_offset; }; struct _arguments { asdl_seq *args; identifier vararg; identifier kwarg; asdl_seq *defaults; asdl_seq *type_comments; }; struct _keyword { identifier arg; expr_ty value; }; struct _alias { identifier name; identifier asname; }; enum _type_ignore_kind {TypeIgnore_kind=1}; struct _type_ignore { enum _type_ignore_kind kind; union { struct { int lineno; } TypeIgnore; } v; }; #define Module(a0, a1, a2) _Ta27_Module(a0, a1, a2) mod_ty _Ta27_Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena); #define Interactive(a0, a1) _Ta27_Interactive(a0, a1) mod_ty _Ta27_Interactive(asdl_seq * body, PyArena *arena); #define Expression(a0, a1) _Ta27_Expression(a0, a1) mod_ty _Ta27_Expression(expr_ty body, PyArena *arena); #define FunctionType(a0, a1, a2) _Ta27_FunctionType(a0, a1, a2) mod_ty _Ta27_FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena); #define Suite(a0, a1) _Ta27_Suite(a0, a1) mod_ty _Ta27_Suite(asdl_seq * body, PyArena *arena); #define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) _Ta27_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Ta27_FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, string type_comment, int lineno, int col_offset, PyArena *arena); #define ClassDef(a0, a1, a2, a3, a4, a5, a6) _Ta27_ClassDef(a0, a1, a2, a3, a4, a5, a6) stmt_ty _Ta27_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, asdl_seq * decorator_list, int lineno, int col_offset, PyArena *arena); #define Return(a0, a1, a2, a3) _Ta27_Return(a0, a1, a2, a3) stmt_ty _Ta27_Return(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Delete(a0, a1, a2, a3) _Ta27_Delete(a0, a1, a2, a3) stmt_ty _Ta27_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena); #define Assign(a0, a1, a2, a3, a4, a5) _Ta27_Assign(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int col_offset, PyArena *arena); #define AugAssign(a0, a1, a2, a3, a4, a5) _Ta27_AugAssign(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int col_offset, PyArena *arena); #define Print(a0, a1, a2, a3, a4, a5) _Ta27_Print(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset, PyArena *arena); #define For(a0, a1, a2, a3, a4, a5, a6, a7) _Ta27_For(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Ta27_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena); #define While(a0, a1, a2, a3, a4, a5) _Ta27_While(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena); #define If(a0, a1, a2, a3, a4, a5) _Ta27_If(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena); #define With(a0, a1, a2, a3, a4, a5, a6) _Ta27_With(a0, a1, a2, a3, a4, a5, a6) stmt_ty _Ta27_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena); #define Raise(a0, a1, a2, a3, a4, a5) _Ta27_Raise(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset, PyArena *arena); #define TryExcept(a0, a1, a2, a3, a4, a5) _Ta27_TryExcept(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena); #define TryFinally(a0, a1, a2, a3, a4) _Ta27_TryFinally(a0, a1, a2, a3, a4) stmt_ty _Ta27_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int col_offset, PyArena *arena); #define Assert(a0, a1, a2, a3, a4) _Ta27_Assert(a0, a1, a2, a3, a4) stmt_ty _Ta27_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena); #define Import(a0, a1, a2, a3) _Ta27_Import(a0, a1, a2, a3) stmt_ty _Ta27_Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena); #define ImportFrom(a0, a1, a2, a3, a4, a5) _Ta27_ImportFrom(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int col_offset, PyArena *arena); #define Exec(a0, a1, a2, a3, a4, a5) _Ta27_Exec(a0, a1, a2, a3, a4, a5) stmt_ty _Ta27_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int col_offset, PyArena *arena); #define Global(a0, a1, a2, a3) _Ta27_Global(a0, a1, a2, a3) stmt_ty _Ta27_Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena); #define Expr(a0, a1, a2, a3) _Ta27_Expr(a0, a1, a2, a3) stmt_ty _Ta27_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Pass(a0, a1, a2) _Ta27_Pass(a0, a1, a2) stmt_ty _Ta27_Pass(int lineno, int col_offset, PyArena *arena); #define Break(a0, a1, a2) _Ta27_Break(a0, a1, a2) stmt_ty _Ta27_Break(int lineno, int col_offset, PyArena *arena); #define Continue(a0, a1, a2) _Ta27_Continue(a0, a1, a2) stmt_ty _Ta27_Continue(int lineno, int col_offset, PyArena *arena); #define BoolOp(a0, a1, a2, a3, a4) _Ta27_BoolOp(a0, a1, a2, a3, a4) expr_ty _Ta27_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena *arena); #define BinOp(a0, a1, a2, a3, a4, a5) _Ta27_BinOp(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset, PyArena *arena); #define UnaryOp(a0, a1, a2, a3, a4) _Ta27_UnaryOp(a0, a1, a2, a3, a4) expr_ty _Ta27_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena *arena); #define Lambda(a0, a1, a2, a3, a4) _Ta27_Lambda(a0, a1, a2, a3, a4) expr_ty _Ta27_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena *arena); #define IfExp(a0, a1, a2, a3, a4, a5) _Ta27_IfExp(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset, PyArena *arena); #define Dict(a0, a1, a2, a3, a4) _Ta27_Dict(a0, a1, a2, a3, a4) expr_ty _Ta27_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena *arena); #define Set(a0, a1, a2, a3) _Ta27_Set(a0, a1, a2, a3) expr_ty _Ta27_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena); #define ListComp(a0, a1, a2, a3, a4) _Ta27_ListComp(a0, a1, a2, a3, a4) expr_ty _Ta27_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define SetComp(a0, a1, a2, a3, a4) _Ta27_SetComp(a0, a1, a2, a3, a4) expr_ty _Ta27_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define DictComp(a0, a1, a2, a3, a4, a5) _Ta27_DictComp(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define GeneratorExp(a0, a1, a2, a3, a4) _Ta27_GeneratorExp(a0, a1, a2, a3, a4) expr_ty _Ta27_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define Yield(a0, a1, a2, a3) _Ta27_Yield(a0, a1, a2, a3) expr_ty _Ta27_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Compare(a0, a1, a2, a3, a4, a5) _Ta27_Compare(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, int col_offset, PyArena *arena); #define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Ta27_Call(a0, a1, a2, a3, a4, a5, a6, a7) expr_ty _Ta27_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, expr_ty kwargs, int lineno, int col_offset, PyArena *arena); #define Repr(a0, a1, a2, a3) _Ta27_Repr(a0, a1, a2, a3) expr_ty _Ta27_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Num(a0, a1, a2, a3) _Ta27_Num(a0, a1, a2, a3) expr_ty _Ta27_Num(object n, int lineno, int col_offset, PyArena *arena); #define Str(a0, a1, a2, a3, a4) _Ta27_Str(a0, a1, a2, a3, a4) expr_ty _Ta27_Str(string s, int has_b, int lineno, int col_offset, PyArena *arena); #define Attribute(a0, a1, a2, a3, a4, a5) _Ta27_Attribute(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Subscript(a0, a1, a2, a3, a4, a5) _Ta27_Subscript(a0, a1, a2, a3, a4, a5) expr_ty _Ta27_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Name(a0, a1, a2, a3, a4) _Ta27_Name(a0, a1, a2, a3, a4) expr_ty _Ta27_Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define List(a0, a1, a2, a3, a4) _Ta27_List(a0, a1, a2, a3, a4) expr_ty _Ta27_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Tuple(a0, a1, a2, a3, a4) _Ta27_Tuple(a0, a1, a2, a3, a4) expr_ty _Ta27_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Ellipsis(a0) _Ta27_Ellipsis(a0) slice_ty _Ta27_Ellipsis(PyArena *arena); #define Slice(a0, a1, a2, a3) _Ta27_Slice(a0, a1, a2, a3) slice_ty _Ta27_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena); #define ExtSlice(a0, a1) _Ta27_ExtSlice(a0, a1) slice_ty _Ta27_ExtSlice(asdl_seq * dims, PyArena *arena); #define Index(a0, a1) _Ta27_Index(a0, a1) slice_ty _Ta27_Index(expr_ty value, PyArena *arena); #define comprehension(a0, a1, a2, a3) _Ta27_comprehension(a0, a1, a2, a3) comprehension_ty _Ta27_comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena); #define ExceptHandler(a0, a1, a2, a3, a4, a5) _Ta27_ExceptHandler(a0, a1, a2, a3, a4, a5) excepthandler_ty _Ta27_ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int col_offset, PyArena *arena); #define arguments(a0, a1, a2, a3, a4, a5) _Ta27_arguments(a0, a1, a2, a3, a4, a5) arguments_ty _Ta27_arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq * defaults, asdl_seq * type_comments, PyArena *arena); #define keyword(a0, a1, a2) _Ta27_keyword(a0, a1, a2) keyword_ty _Ta27_keyword(identifier arg, expr_ty value, PyArena *arena); #define alias(a0, a1, a2) _Ta27_alias(a0, a1, a2) alias_ty _Ta27_alias(identifier name, identifier asname, PyArena *arena); #define TypeIgnore(a0, a1) _Ta27_TypeIgnore(a0, a1) type_ignore_ty _Ta27_TypeIgnore(int lineno, PyArena *arena); PyObject* Ta27AST_mod2obj(mod_ty t); mod_ty Ta27AST_obj2mod(PyObject* ast, PyArena* arena, int mode); int Ta27AST_Check(PyObject* obj); typed-ast-1.1.0/ast27/Include/token.h0000644€Tøžæ€2›s®0000000346713050216645020550 0ustar ddfisher00000000000000 /* Token types */ #ifndef Ta27_TOKEN_H #define Ta27_TOKEN_H #ifdef __cplusplus extern "C" { #endif #undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */ #define ENDMARKER 0 #define NAME 1 #define NUMBER 2 #define STRING 3 #define NEWLINE 4 #define INDENT 5 #define DEDENT 6 #define LPAR 7 #define RPAR 8 #define LSQB 9 #define RSQB 10 #define COLON 11 #define COMMA 12 #define SEMI 13 #define PLUS 14 #define MINUS 15 #define STAR 16 #define SLASH 17 #define VBAR 18 #define AMPER 19 #define LESS 20 #define GREATER 21 #define EQUAL 22 #define DOT 23 #define PERCENT 24 #define BACKQUOTE 25 #define LBRACE 26 #define RBRACE 27 #define EQEQUAL 28 #define NOTEQUAL 29 #define LESSEQUAL 30 #define GREATEREQUAL 31 #define TILDE 32 #define CIRCUMFLEX 33 #define LEFTSHIFT 34 #define RIGHTSHIFT 35 #define DOUBLESTAR 36 #define PLUSEQUAL 37 #define MINEQUAL 38 #define STAREQUAL 39 #define SLASHEQUAL 40 #define PERCENTEQUAL 41 #define AMPEREQUAL 42 #define VBAREQUAL 43 #define CIRCUMFLEXEQUAL 44 #define LEFTSHIFTEQUAL 45 #define RIGHTSHIFTEQUAL 46 #define DOUBLESTAREQUAL 47 #define DOUBLESLASH 48 #define DOUBLESLASHEQUAL 49 #define AT 50 /* Don't forget to update the table _Ta27Parser_TokenNames in tokenizer.c! */ #define OP 51 #define RARROW 52 #define TYPE_IGNORE 53 #define TYPE_COMMENT 54 #define ERRORTOKEN 55 #define N_TOKENS 56 /* Special definitions for cooperation with parser */ #define NT_OFFSET 256 #define ISTERMINAL(x) ((x) < NT_OFFSET) #define ISNONTERMINAL(x) ((x) >= NT_OFFSET) #define ISEOF(x) ((x) == ENDMARKER) extern char *_Ta27Parser_TokenNames[]; /* Token names */ int Ta27Token_OneChar(int); int Ta27Token_TwoChars(int, int); int Ta27Token_ThreeChars(int, int, int); #ifdef __cplusplus } #endif #endif /* !Ta27_TOKEN_H */ typed-ast-1.1.0/ast27/Parser/0000755€Tøžæ€2›s®0000000000013133476735017130 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/Parser/acceler.c0000644€Tøžæ€2›s®0000000644013050216645020664 0ustar ddfisher00000000000000 /* Parser accelerator module */ /* The parser as originally conceived had disappointing performance. This module does some precomputation that speeds up the selection of a DFA based upon a token, turning a search through an array into a simple indexing operation. The parser now cannot work without the accelerators installed. Note that the accelerators are installed dynamically when the parser is initialized, they are not part of the static data structure written on graminit.[ch] by the parser generator. */ #include "pgenheaders.h" #include "grammar.h" #include "node.h" #include "token.h" #include "parser.h" /* Forward references */ static void fixdfa(grammar *, dfa *); static void fixstate(grammar *, state *); void Ta27Grammar_AddAccelerators(grammar *g) { dfa *d; int i; d = g->g_dfa; for (i = g->g_ndfas; --i >= 0; d++) fixdfa(g, d); g->g_accel = 1; } void Ta27Grammar_RemoveAccelerators(grammar *g) { dfa *d; int i; g->g_accel = 0; d = g->g_dfa; for (i = g->g_ndfas; --i >= 0; d++) { state *s; int j; s = d->d_state; for (j = 0; j < d->d_nstates; j++, s++) { if (s->s_accel) PyObject_FREE(s->s_accel); s->s_accel = NULL; } } } static void fixdfa(grammar *g, dfa *d) { state *s; int j; s = d->d_state; for (j = 0; j < d->d_nstates; j++, s++) fixstate(g, s); } static void fixstate(grammar *g, state *s) { arc *a; int k; int *accel; int nl = g->g_ll.ll_nlabels; s->s_accept = 0; accel = (int *) PyObject_MALLOC(nl * sizeof(int)); if (accel == NULL) { fprintf(stderr, "no mem to build parser accelerators\n"); exit(1); } for (k = 0; k < nl; k++) accel[k] = -1; a = s->s_arc; for (k = s->s_narcs; --k >= 0; a++) { int lbl = a->a_lbl; label *l = &g->g_ll.ll_label[lbl]; int type = l->lb_type; if (a->a_arrow >= (1 << 7)) { printf("XXX too many states!\n"); continue; } if (ISNONTERMINAL(type)) { dfa *d1 = Ta27Grammar_FindDFA(g, type); int ibit; if (type - NT_OFFSET >= (1 << 7)) { printf("XXX too high nonterminal number!\n"); continue; } for (ibit = 0; ibit < g->g_ll.ll_nlabels; ibit++) { if (testbit(d1->d_first, ibit)) { if (accel[ibit] != -1) printf("XXX ambiguity!\n"); accel[ibit] = a->a_arrow | (1 << 7) | ((type - NT_OFFSET) << 8); } } } else if (lbl == EMPTY) s->s_accept = 1; else if (lbl >= 0 && lbl < nl) accel[lbl] = a->a_arrow; } while (nl > 0 && accel[nl-1] == -1) nl--; for (k = 0; k < nl && accel[k] == -1;) k++; if (k < nl) { int i; s->s_accel = (int *) PyObject_MALLOC((nl-k) * sizeof(int)); if (s->s_accel == NULL) { fprintf(stderr, "no mem to add parser accelerators\n"); exit(1); } s->s_lower = k; s->s_upper = nl; for (i = 0; k < nl; i++, k++) s->s_accel[i] = accel[k]; } PyObject_FREE(accel); } typed-ast-1.1.0/ast27/Parser/bitset.c0000644€Tøžæ€2›s®0000000205113050216645020552 0ustar ddfisher00000000000000 /* Bitset primitives used by the parser generator */ #include "pgenheaders.h" #include "bitset.h" bitset newbitset(int nbits) { int nbytes = NBYTES(nbits); bitset ss = (char *)PyObject_MALLOC(sizeof(BYTE) * nbytes); if (ss == NULL) Py_FatalError("no mem for bitset"); ss += nbytes; while (--nbytes >= 0) *--ss = 0; return ss; } void delbitset(bitset ss) { PyObject_FREE(ss); } int addbit(bitset ss, int ibit) { int ibyte = BIT2BYTE(ibit); BYTE mask = BIT2MASK(ibit); if (ss[ibyte] & mask) return 0; /* Bit already set */ ss[ibyte] |= mask; return 1; } #if 0 /* Now a macro */ int testbit(bitset ss, int ibit) { return (ss[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0; } #endif int samebitset(bitset ss1, bitset ss2, int nbits) { int i; for (i = NBYTES(nbits); --i >= 0; ) if (*ss1++ != *ss2++) return 0; return 1; } void mergebitset(bitset ss1, bitset ss2, int nbits) { int i; for (i = NBYTES(nbits); --i >= 0; ) *ss1++ |= *ss2++; } typed-ast-1.1.0/ast27/Parser/grammar.c0000644€Tøžæ€2›s®0000001540213050216645020712 0ustar ddfisher00000000000000 /* Grammar implementation */ #include "Python.h" #include "pgenheaders.h" #include #include "token.h" #include "grammar.h" #ifdef RISCOS #include #endif PyAPI_DATA(int) Py_DebugFlag; grammar * newgrammar(int start) { grammar *g; g = (grammar *)PyObject_MALLOC(sizeof(grammar)); if (g == NULL) Py_FatalError("no mem for new grammar"); g->g_ndfas = 0; g->g_dfa = NULL; g->g_start = start; g->g_ll.ll_nlabels = 0; g->g_ll.ll_label = NULL; g->g_accel = 0; return g; } dfa * adddfa(grammar *g, int type, char *name) { dfa *d; g->g_dfa = (dfa *)PyObject_REALLOC(g->g_dfa, sizeof(dfa) * (g->g_ndfas + 1)); if (g->g_dfa == NULL) Py_FatalError("no mem to resize dfa in adddfa"); d = &g->g_dfa[g->g_ndfas++]; d->d_type = type; d->d_name = strdup(name); d->d_nstates = 0; d->d_state = NULL; d->d_initial = -1; d->d_first = NULL; return d; /* Only use while fresh! */ } int addstate(dfa *d) { state *s; d->d_state = (state *)PyObject_REALLOC(d->d_state, sizeof(state) * (d->d_nstates + 1)); if (d->d_state == NULL) Py_FatalError("no mem to resize state in addstate"); s = &d->d_state[d->d_nstates++]; s->s_narcs = 0; s->s_arc = NULL; s->s_lower = 0; s->s_upper = 0; s->s_accel = NULL; s->s_accept = 0; return s - d->d_state; } void addarc(dfa *d, int from, int to, int lbl) { state *s; arc *a; assert(0 <= from && from < d->d_nstates); assert(0 <= to && to < d->d_nstates); s = &d->d_state[from]; s->s_arc = (arc *)PyObject_REALLOC(s->s_arc, sizeof(arc) * (s->s_narcs + 1)); if (s->s_arc == NULL) Py_FatalError("no mem to resize arc list in addarc"); a = &s->s_arc[s->s_narcs++]; a->a_lbl = lbl; a->a_arrow = to; } int addlabel(labellist *ll, int type, char *str) { int i; label *lb; for (i = 0; i < ll->ll_nlabels; i++) { if (ll->ll_label[i].lb_type == type && strcmp(ll->ll_label[i].lb_str, str) == 0) return i; } ll->ll_label = (label *)PyObject_REALLOC(ll->ll_label, sizeof(label) * (ll->ll_nlabels + 1)); if (ll->ll_label == NULL) Py_FatalError("no mem to resize labellist in addlabel"); lb = &ll->ll_label[ll->ll_nlabels++]; lb->lb_type = type; lb->lb_str = strdup(str); if (Py_DebugFlag) printf("Label @ %8p, %d: %s\n", ll, ll->ll_nlabels, Ta27Grammar_LabelRepr(lb)); return lb - ll->ll_label; } /* Same, but rather dies than adds */ int findlabel(labellist *ll, int type, char *str) { int i; for (i = 0; i < ll->ll_nlabels; i++) { if (ll->ll_label[i].lb_type == type /*&& strcmp(ll->ll_label[i].lb_str, str) == 0*/) return i; } fprintf(stderr, "Label %d/'%s' not found\n", type, str); Py_FatalError("grammar.c:findlabel()"); return 0; /* Make gcc -Wall happy */ } /* Forward */ static void translabel(grammar *, label *); void translatelabels(grammar *g) { int i; #ifdef Py_DEBUG printf("Translating labels ...\n"); #endif /* Don't translate EMPTY */ for (i = EMPTY+1; i < g->g_ll.ll_nlabels; i++) translabel(g, &g->g_ll.ll_label[i]); } static void translabel(grammar *g, label *lb) { int i; if (Py_DebugFlag) printf("Translating label %s ...\n", Ta27Grammar_LabelRepr(lb)); if (lb->lb_type == NAME) { for (i = 0; i < g->g_ndfas; i++) { if (strcmp(lb->lb_str, g->g_dfa[i].d_name) == 0) { if (Py_DebugFlag) printf( "Label %s is non-terminal %d.\n", lb->lb_str, g->g_dfa[i].d_type); lb->lb_type = g->g_dfa[i].d_type; free(lb->lb_str); lb->lb_str = NULL; return; } } for (i = 0; i < (int)N_TOKENS; i++) { if (strcmp(lb->lb_str, _Ta27Parser_TokenNames[i]) == 0) { if (Py_DebugFlag) printf("Label %s is terminal %d.\n", lb->lb_str, i); lb->lb_type = i; free(lb->lb_str); lb->lb_str = NULL; return; } } printf("Can't translate NAME label '%s'\n", lb->lb_str); return; } if (lb->lb_type == STRING) { if (isalpha(Py_CHARMASK(lb->lb_str[1])) || lb->lb_str[1] == '_') { char *p; char *src; char *dest; size_t name_len; if (Py_DebugFlag) printf("Label %s is a keyword\n", lb->lb_str); lb->lb_type = NAME; src = lb->lb_str + 1; p = strchr(src, '\''); if (p) name_len = p - src; else name_len = strlen(src); dest = (char *)malloc(name_len + 1); if (!dest) { printf("Can't alloc dest '%s'\n", src); return; } strncpy(dest, src, name_len); dest[name_len] = '\0'; free(lb->lb_str); lb->lb_str = dest; } else if (lb->lb_str[2] == lb->lb_str[0]) { int type = (int) Ta27Token_OneChar(lb->lb_str[1]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else if (lb->lb_str[2] && lb->lb_str[3] == lb->lb_str[0]) { int type = (int) Ta27Token_TwoChars(lb->lb_str[1], lb->lb_str[2]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else if (lb->lb_str[2] && lb->lb_str[3] && lb->lb_str[4] == lb->lb_str[0]) { int type = (int) Ta27Token_ThreeChars(lb->lb_str[1], lb->lb_str[2], lb->lb_str[3]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else printf("Can't translate STRING label %s\n", lb->lb_str); } else printf("Can't translate label '%s'\n", Ta27Grammar_LabelRepr(lb)); } typed-ast-1.1.0/ast27/Parser/grammar1.c0000644€Tøžæ€2›s®0000000230313050216645020767 0ustar ddfisher00000000000000 /* Grammar subroutines needed by parser */ #include "Python.h" #include "pgenheaders.h" #include "grammar.h" #include "token.h" /* Return the DFA for the given type */ dfa * Ta27Grammar_FindDFA(grammar *g, register int type) { register dfa *d; #if 1 /* Massive speed-up */ d = &g->g_dfa[type - NT_OFFSET]; assert(d->d_type == type); return d; #else /* Old, slow version */ register int i; for (i = g->g_ndfas, d = g->g_dfa; --i >= 0; d++) { if (d->d_type == type) return d; } assert(0); /* NOTREACHED */ #endif } char * Ta27Grammar_LabelRepr(label *lb) { static char buf[100]; if (lb->lb_type == ENDMARKER) return "EMPTY"; else if (ISNONTERMINAL(lb->lb_type)) { if (lb->lb_str == NULL) { PyOS_snprintf(buf, sizeof(buf), "NT%d", lb->lb_type); return buf; } else return lb->lb_str; } else { if (lb->lb_str == NULL) return _Ta27Parser_TokenNames[lb->lb_type]; else { PyOS_snprintf(buf, sizeof(buf), "%.32s(%.32s)", _Ta27Parser_TokenNames[lb->lb_type], lb->lb_str); return buf; } } } typed-ast-1.1.0/ast27/Parser/node.c0000644€Tøžæ€2›s®0000001070213050216645020207 0ustar ddfisher00000000000000/* Parse tree node implementation */ #include "Python.h" #include "node.h" #include "errcode.h" node * Ta27Node_New(int type) { node *n = (node *) PyObject_MALLOC(1 * sizeof(node)); if (n == NULL) return NULL; n->n_type = type; n->n_str = NULL; n->n_lineno = 0; n->n_nchildren = 0; n->n_child = NULL; return n; } /* See comments at XXXROUNDUP below. Returns -1 on overflow. */ static int fancy_roundup(int n) { /* Round up to the closest power of 2 >= n. */ int result = 256; assert(n > 128); while (result < n) { result <<= 1; if (result <= 0) return -1; } return result; } /* A gimmick to make massive numbers of reallocs quicker. The result is * a number >= the input. In Ta27Node_AddChild, it's used like so, when * we're about to add child number current_size + 1: * * if XXXROUNDUP(current_size) < XXXROUNDUP(current_size + 1): * allocate space for XXXROUNDUP(current_size + 1) total children * else: * we already have enough space * * Since a node starts out empty, we must have * * XXXROUNDUP(0) < XXXROUNDUP(1) * * so that we allocate space for the first child. One-child nodes are very * common (presumably that would change if we used a more abstract form * of syntax tree), so to avoid wasting memory it's desirable that * XXXROUNDUP(1) == 1. That in turn forces XXXROUNDUP(0) == 0. * * Else for 2 <= n <= 128, we round up to the closest multiple of 4. Why 4? * Rounding up to a multiple of an exact power of 2 is very efficient, and * most nodes with more than one child have <= 4 kids. * * Else we call fancy_roundup() to grow proportionately to n. We've got an * extreme case then (like test_longexp.py), and on many platforms doing * anything less than proportional growth leads to exorbitant runtime * (e.g., MacPython), or extreme fragmentation of user address space (e.g., * Win98). * * In a run of compileall across the 2.3a0 Lib directory, Andrew MacIntyre * reported that, with this scheme, 89% of PyObject_REALLOC calls in * Ta27Node_AddChild passed 1 for the size, and 9% passed 4. So this usually * wastes very little memory, but is very effective at sidestepping * platform-realloc disasters on vulnerable platforms. * * Note that this would be straightforward if a node stored its current * capacity. The code is tricky to avoid that. */ #define XXXROUNDUP(n) ((n) <= 1 ? (n) : \ (n) <= 128 ? (((n) + 3) & ~3) : \ fancy_roundup(n)) int Ta27Node_AddChild(register node *n1, int type, char *str, int lineno, int col_offset) { const int nch = n1->n_nchildren; int current_capacity; int required_capacity; node *n; if (nch == INT_MAX || nch < 0) return E_OVERFLOW; current_capacity = XXXROUNDUP(nch); required_capacity = XXXROUNDUP(nch + 1); if (current_capacity < 0 || required_capacity < 0) return E_OVERFLOW; if (current_capacity < required_capacity) { if ((size_t)required_capacity > PY_SIZE_MAX / sizeof(node)) { return E_NOMEM; } n = n1->n_child; n = (node *) PyObject_REALLOC(n, required_capacity * sizeof(node)); if (n == NULL) return E_NOMEM; n1->n_child = n; } n = &n1->n_child[n1->n_nchildren++]; n->n_type = type; n->n_str = str; n->n_lineno = lineno; n->n_col_offset = col_offset; n->n_nchildren = 0; n->n_child = NULL; return 0; } /* Forward */ static void freechildren(node *); static Py_ssize_t sizeofchildren(node *n); void Ta27Node_Free(node *n) { if (n != NULL) { freechildren(n); PyObject_FREE(n); } } Py_ssize_t _Ta27Node_SizeOf(node *n) { Py_ssize_t res = 0; if (n != NULL) res = sizeof(node) + sizeofchildren(n); return res; } static void freechildren(node *n) { int i; for (i = NCH(n); --i >= 0; ) freechildren(CHILD(n, i)); if (n->n_child != NULL) PyObject_FREE(n->n_child); if (STR(n) != NULL) PyObject_FREE(STR(n)); } static Py_ssize_t sizeofchildren(node *n) { Py_ssize_t res = 0; int i; for (i = NCH(n); --i >= 0; ) res += sizeofchildren(CHILD(n, i)); if (n->n_child != NULL) /* allocated size of n->n_child array */ res += XXXROUNDUP(NCH(n)) * sizeof(node); if (STR(n) != NULL) res += strlen(STR(n)) + 1; return res; } typed-ast-1.1.0/ast27/Parser/parser.c0000644€Tøžæ€2›s®0000002700713050216645020564 0ustar ddfisher00000000000000 /* Parser implementation */ /* For a description, see the comments at end of this file */ /* XXX To do: error recovery */ #include "Python.h" #include "pgenheaders.h" #include "token.h" #include "grammar.h" #include "node.h" #include "parser.h" #include "errcode.h" #ifdef Py_DEBUG extern int Py_DebugFlag; #define D(x) if (!Py_DebugFlag); else x #else #define D(x) #endif /* STACK DATA TYPE */ static void s_reset(stack *); static void s_reset(stack *s) { s->s_top = &s->s_base[MAXSTACK]; } #define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK]) static int s_push(register stack *s, dfa *d, node *parent) { register stackentry *top; if (s->s_top == s->s_base) { fprintf(stderr, "s_push: parser stack overflow\n"); return E_NOMEM; } top = --s->s_top; top->s_dfa = d; top->s_parent = parent; top->s_state = 0; return 0; } #ifdef Py_DEBUG static void s_pop(register stack *s) { if (s_empty(s)) Py_FatalError("s_pop: parser stack underflow -- FATAL"); s->s_top++; } #else /* !Py_DEBUG */ #define s_pop(s) (s)->s_top++ #endif /* PARSER CREATION */ parser_state * Ta27Parser_New(grammar *g, int start) { parser_state *ps; if (!g->g_accel) Ta27Grammar_AddAccelerators(g); ps = (parser_state *)PyMem_MALLOC(sizeof(parser_state)); if (ps == NULL) return NULL; ps->p_grammar = g; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD ps->p_flags = 0; #endif ps->p_tree = Ta27Node_New(start); if (ps->p_tree == NULL) { PyMem_FREE(ps); return NULL; } s_reset(&ps->p_stack); (void) s_push(&ps->p_stack, Ta27Grammar_FindDFA(g, start), ps->p_tree); return ps; } void Ta27Parser_Delete(parser_state *ps) { /* NB If you want to save the parse tree, you must set p_tree to NULL before calling delparser! */ Ta27Node_Free(ps->p_tree); PyMem_FREE(ps); } /* PARSER STACK OPERATIONS */ static int shift(register stack *s, int type, char *str, int newstate, int lineno, int col_offset) { int err; assert(!s_empty(s)); err = Ta27Node_AddChild(s->s_top->s_parent, type, str, lineno, col_offset); if (err) return err; s->s_top->s_state = newstate; return 0; } static int push(register stack *s, int type, dfa *d, int newstate, int lineno, int col_offset) { int err; register node *n; n = s->s_top->s_parent; assert(!s_empty(s)); err = Ta27Node_AddChild(n, type, (char *)NULL, lineno, col_offset); if (err) return err; s->s_top->s_state = newstate; return s_push(s, d, CHILD(n, NCH(n)-1)); } /* PARSER PROPER */ static int classify(parser_state *ps, int type, char *str) { grammar *g = ps->p_grammar; register int n = g->g_ll.ll_nlabels; if (type == NAME) { register char *s = str; register label *l = g->g_ll.ll_label; register int i; for (i = n; i > 0; i--, l++) { if (l->lb_type != NAME || l->lb_str == NULL || l->lb_str[0] != s[0] || strcmp(l->lb_str, s) != 0) continue; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (ps->p_flags & CO_FUTURE_PRINT_FUNCTION && s[0] == 'p' && strcmp(s, "print") == 0) { break; /* no longer a keyword */ } #endif D(printf("It's a keyword\n")); return n - i; } } { register label *l = g->g_ll.ll_label; register int i; for (i = n; i > 0; i--, l++) { if (l->lb_type == type && l->lb_str == NULL) { D(printf("It's a token we know\n")); return n - i; } } } D(printf("Illegal token\n")); return -1; } #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD static void future_hack(parser_state *ps) { node *n = ps->p_stack.s_top->s_parent; node *ch, *cch; int i; /* from __future__ import ..., must have at least 4 children */ n = CHILD(n, 0); if (NCH(n) < 4) return; ch = CHILD(n, 0); if (STR(ch) == NULL || strcmp(STR(ch), "from") != 0) return; ch = CHILD(n, 1); if (NCH(ch) == 1 && STR(CHILD(ch, 0)) && strcmp(STR(CHILD(ch, 0)), "__future__") != 0) return; ch = CHILD(n, 3); /* ch can be a star, a parenthesis or import_as_names */ if (TYPE(ch) == STAR) return; if (TYPE(ch) == LPAR) ch = CHILD(n, 4); for (i = 0; i < NCH(ch); i += 2) { cch = CHILD(ch, i); if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME) { char *str_ch = STR(CHILD(cch, 0)); if (strcmp(str_ch, FUTURE_WITH_STATEMENT) == 0) { ps->p_flags |= CO_FUTURE_WITH_STATEMENT; } else if (strcmp(str_ch, FUTURE_PRINT_FUNCTION) == 0) { ps->p_flags |= CO_FUTURE_PRINT_FUNCTION; } else if (strcmp(str_ch, FUTURE_UNICODE_LITERALS) == 0) { ps->p_flags |= CO_FUTURE_UNICODE_LITERALS; } } } } #endif /* future keyword */ int Ta27Parser_AddToken(register parser_state *ps, register int type, char *str, int lineno, int col_offset, int *expected_ret) { register int ilabel; int err; D(printf("Token %s/'%s' ... ", _Ta27Parser_TokenNames[type], str)); /* Find out which label this token is */ ilabel = classify(ps, type, str); if (ilabel < 0) return E_SYNTAX; /* Loop until the token is shifted or an error occurred */ for (;;) { /* Fetch the current dfa and state */ register dfa *d = ps->p_stack.s_top->s_dfa; register state *s = &d->d_state[ps->p_stack.s_top->s_state]; D(printf(" DFA '%s', state %d:", d->d_name, ps->p_stack.s_top->s_state)); /* Check accelerator */ if (s->s_lower <= ilabel && ilabel < s->s_upper) { register int x = s->s_accel[ilabel - s->s_lower]; if (x != -1) { if (x & (1<<7)) { /* Push non-terminal */ int nt = (x >> 8) + NT_OFFSET; int arrow = x & ((1<<7)-1); dfa *d1 = Ta27Grammar_FindDFA( ps->p_grammar, nt); if ((err = push(&ps->p_stack, nt, d1, arrow, lineno, col_offset)) > 0) { D(printf(" MemError: push\n")); return err; } D(printf(" Push ...\n")); continue; } /* Shift the token */ if ((err = shift(&ps->p_stack, type, str, x, lineno, col_offset)) > 0) { D(printf(" MemError: shift.\n")); return err; } D(printf(" Shift.\n")); /* Pop while we are in an accept-only state */ while (s = &d->d_state [ps->p_stack.s_top->s_state], s->s_accept && s->s_narcs == 1) { D(printf(" DFA '%s', state %d: " "Direct pop.\n", d->d_name, ps->p_stack.s_top->s_state)); #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (d->d_name[0] == 'i' && strcmp(d->d_name, "import_stmt") == 0) future_hack(ps); #endif s_pop(&ps->p_stack); if (s_empty(&ps->p_stack)) { D(printf(" ACCEPT.\n")); return E_DONE; } d = ps->p_stack.s_top->s_dfa; } return E_OK; } } if (s->s_accept) { #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (d->d_name[0] == 'i' && strcmp(d->d_name, "import_stmt") == 0) future_hack(ps); #endif /* Pop this dfa and try again */ s_pop(&ps->p_stack); D(printf(" Pop ...\n")); if (s_empty(&ps->p_stack)) { D(printf(" Error: bottom of stack.\n")); return E_SYNTAX; } continue; } /* Stuck, report syntax error */ D(printf(" Error.\n")); if (expected_ret) { if (s->s_lower == s->s_upper - 1) { /* Only one possible expected token */ *expected_ret = ps->p_grammar-> g_ll.ll_label[s->s_lower].lb_type; } else *expected_ret = -1; } return E_SYNTAX; } } #ifdef Py_DEBUG /* DEBUG OUTPUT */ void dumptree(grammar *g, node *n) { int i; if (n == NULL) printf("NIL"); else { label l; l.lb_type = TYPE(n); l.lb_str = STR(n); printf("%s", Ta27Grammar_LabelRepr(&l)); if (ISNONTERMINAL(TYPE(n))) { printf("("); for (i = 0; i < NCH(n); i++) { if (i > 0) printf(","); dumptree(g, CHILD(n, i)); } printf(")"); } } } void showtree(grammar *g, node *n) { int i; if (n == NULL) return; if (ISNONTERMINAL(TYPE(n))) { for (i = 0; i < NCH(n); i++) showtree(g, CHILD(n, i)); } else if (ISTERMINAL(TYPE(n))) { printf("%s", _Ta27Parser_TokenNames[TYPE(n)]); if (TYPE(n) == NUMBER || TYPE(n) == NAME) printf("(%s)", STR(n)); printf(" "); } else printf("? "); } void printtree(parser_state *ps) { if (Py_DebugFlag) { printf("Parse tree:\n"); dumptree(ps->p_grammar, ps->p_tree); printf("\n"); printf("Tokens:\n"); showtree(ps->p_grammar, ps->p_tree); printf("\n"); } printf("Listing:\n"); PyNode_ListTree(ps->p_tree); printf("\n"); } #endif /* Py_DEBUG */ /* Description ----------- The parser's interface is different than usual: the function addtoken() must be called for each token in the input. This makes it possible to turn it into an incremental parsing system later. The parsing system constructs a parse tree as it goes. A parsing rule is represented as a Deterministic Finite-state Automaton (DFA). A node in a DFA represents a state of the parser; an arc represents a transition. Transitions are either labeled with terminal symbols or with non-terminals. When the parser decides to follow an arc labeled with a non-terminal, it is invoked recursively with the DFA representing the parsing rule for that as its initial state; when that DFA accepts, the parser that invoked it continues. The parse tree constructed by the recursively called parser is inserted as a child in the current parse tree. The DFA's can be constructed automatically from a more conventional language description. An extended LL(1) grammar (ELL(1)) is suitable. Certain restrictions make the parser's life easier: rules that can produce the empty string should be outlawed (there are other ways to put loops or optional parts in the language). To avoid the need to construct FIRST sets, we can require that all but the last alternative of a rule (really: arc going out of a DFA's state) must begin with a terminal symbol. As an example, consider this grammar: expr: term (OP term)* term: CONSTANT | '(' expr ')' The DFA corresponding to the rule for expr is: ------->.---term-->.-------> ^ | | | \----OP----/ The parse tree generated for the input a+b is: (expr: (term: (NAME: a)), (OP: +), (term: (NAME: b))) */ typed-ast-1.1.0/ast27/Parser/parser.h0000644€Tøžæ€2›s®0000000204013050216645020557 0ustar ddfisher00000000000000#ifndef Ta27_PARSER_H #define Ta27_PARSER_H #ifdef __cplusplus extern "C" { #endif /* Parser interface */ #define MAXSTACK 1500 typedef struct { int s_state; /* State in current DFA */ dfa *s_dfa; /* Current DFA */ struct _node *s_parent; /* Where to add next node */ } stackentry; typedef struct { stackentry *s_top; /* Top entry */ stackentry s_base[MAXSTACK];/* Array of stack entries */ /* NB The stack grows down */ } stack; typedef struct { stack p_stack; /* Stack of parser states */ grammar *p_grammar; /* Grammar to use */ node *p_tree; /* Top of parse tree */ #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD unsigned long p_flags; /* see co_flags in Include/code.h */ #endif } parser_state; parser_state *Ta27Parser_New(grammar *g, int start); void Ta27Parser_Delete(parser_state *ps); int Ta27Parser_AddToken(parser_state *ps, int type, char *str, int lineno, int col_offset, int *expected_ret); void Ta27Grammar_AddAccelerators(grammar *g); #ifdef __cplusplus } #endif #endif /* !Ta27_PARSER_H */ typed-ast-1.1.0/ast27/Parser/parsetok.c0000644€Tøžæ€2›s®0000002507413050216645021122 0ustar ddfisher00000000000000 /* Parser-tokenizer link implementation */ #include "pgenheaders.h" #include "tokenizer.h" #include "node.h" #include "grammar.h" #include "parser.h" #include "parsetok.h" #include "errcode.h" #include "graminit.h" int Ta27_TabcheckFlag; /* Forward */ static node *parsetok(struct tok_state *, grammar *, int, perrdetail *, int *); static void initerr(perrdetail *err_ret, const char* filename); static int initerr_object(perrdetail *err_ret, PyObject *filename); /* Parse input coming from a string. Return error code, print some errors. */ node * Ta27Parser_ParseString(const char *s, grammar *g, int start, perrdetail *err_ret) { return Ta27Parser_ParseStringFlagsFilename(s, NULL, g, start, err_ret, 0); } node * Ta27Parser_ParseStringFlags(const char *s, grammar *g, int start, perrdetail *err_ret, int flags) { return Ta27Parser_ParseStringFlagsFilename(s, NULL, g, start, err_ret, flags); } node * Ta27Parser_ParseStringFlagsFilename(const char *s, const char *filename, grammar *g, int start, perrdetail *err_ret, int flags) { int iflags = flags; return Ta27Parser_ParseStringFlagsFilenameEx(s, filename, g, start, err_ret, &iflags); } node * Ta27Parser_ParseStringFlagsFilenameEx(const char *s, const char *filename, grammar *g, int start, perrdetail *err_ret, int *flags) { struct tok_state *tok; initerr(err_ret, filename); if ((tok = Ta27Tokenizer_FromString(s, start == file_input)) == NULL) { err_ret->error = PyErr_Occurred() ? E_DECODE : E_NOMEM; return NULL; } tok->filename = filename ? filename : ""; if (Ta27_TabcheckFlag || Py_VerboseFlag) { tok->altwarning = (tok->filename != NULL); if (Ta27_TabcheckFlag >= 2) tok->alterror++; } return parsetok(tok, g, start, err_ret, flags); } node * Ta27Parser_ParseStringObject(const char *s, PyObject *filename, grammar *g, int start, perrdetail *err_ret, int *flags) { struct tok_state *tok; int exec_input = start == file_input; initerr_object(err_ret, filename); if (*flags & PyPARSE_IGNORE_COOKIE) tok = Ta27Tokenizer_FromUTF8(s, exec_input); else tok = Ta27Tokenizer_FromString(s, exec_input); if (tok == NULL) { err_ret->error = PyErr_Occurred() ? E_DECODE : E_NOMEM; return NULL; } #ifndef PGEN Py_INCREF(err_ret->filename); tok->filename = PyUnicode_AsUTF8(err_ret->filename); #endif return parsetok(tok, g, start, err_ret, flags); } /* Parse input coming from a file. Return error code, print some errors. */ node * Ta27Parser_ParseFile(FILE *fp, const char *filename, grammar *g, int start, char *ps1, char *ps2, perrdetail *err_ret) { return Ta27Parser_ParseFileFlags(fp, filename, g, start, ps1, ps2, err_ret, 0); } node * Ta27Parser_ParseFileFlags(FILE *fp, const char *filename, grammar *g, int start, char *ps1, char *ps2, perrdetail *err_ret, int flags) { int iflags = flags; return Ta27Parser_ParseFileFlagsEx(fp, filename, g, start, ps1, ps2, err_ret, &iflags); } node * Ta27Parser_ParseFileFlagsEx(FILE *fp, const char *filename, grammar *g, int start, char *ps1, char *ps2, perrdetail *err_ret, int *flags) { struct tok_state *tok; initerr(err_ret, filename); if ((tok = Ta27Tokenizer_FromFile(fp, ps1, ps2)) == NULL) { err_ret->error = E_NOMEM; return NULL; } tok->filename = filename; if (Ta27_TabcheckFlag || Py_VerboseFlag) { tok->altwarning = (filename != NULL); if (Ta27_TabcheckFlag >= 2) tok->alterror++; } return parsetok(tok, g, start, err_ret, flags); } #if 0 static char with_msg[] = "%s:%d: Warning: 'with' will become a reserved keyword in Python 2.6\n"; static char as_msg[] = "%s:%d: Warning: 'as' will become a reserved keyword in Python 2.6\n"; static void warn(const char *msg, const char *filename, int lineno) { if (filename == NULL) filename = ""; PySys_WriteStderr(msg, filename, lineno); } #endif typedef struct { int *items; size_t size; size_t num_items; } growable_int_array; int growable_int_array_init(growable_int_array *arr, size_t initial_size) { assert(initial_size > 0); arr->items = malloc(initial_size * sizeof(*arr->items)); arr->size = initial_size; arr->num_items = 0; return arr->items != NULL; } int growable_int_array_add(growable_int_array *arr, int item) { if (arr->num_items >= arr->size) { arr->size *= 2; arr->items = realloc(arr->items, arr->size * sizeof(*arr->items)); if (!arr->items) return 0; } arr->items[arr->num_items] = item; arr->num_items++; return 1; } void growable_int_array_deallocate(growable_int_array *arr) { free(arr->items); } /* Parse input coming from the given tokenizer structure. Return error code. */ static node * parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret, int *flags) { parser_state *ps; node *n; int started = 0; growable_int_array type_ignores; if (!growable_int_array_init(&type_ignores, 10)) { err_ret->error = E_NOMEM; Ta27Tokenizer_Free(tok); return NULL; } if ((ps = Ta27Parser_New(g, start)) == NULL) { fprintf(stderr, "no mem for new parser\n"); err_ret->error = E_NOMEM; Ta27Tokenizer_Free(tok); return NULL; } #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (*flags & PyPARSE_PRINT_IS_FUNCTION) { ps->p_flags |= CO_FUTURE_PRINT_FUNCTION; } if (*flags & PyPARSE_UNICODE_LITERALS) { ps->p_flags |= CO_FUTURE_UNICODE_LITERALS; } #endif for (;;) { char *a, *b; int type; size_t len; char *str; int col_offset; type = Ta27Tokenizer_Get(tok, &a, &b); if (type == ERRORTOKEN) { err_ret->error = tok->done; break; } if (type == ENDMARKER && started) { type = NEWLINE; /* Add an extra newline */ started = 0; /* Add the right number of dedent tokens, except if a certain flag is given -- codeop.py uses this. */ if (tok->indent && !(*flags & PyPARSE_DONT_IMPLY_DEDENT)) { tok->pendin = -tok->indent; tok->indent = 0; } } else started = 1; len = b - a; /* XXX this may compute NULL - NULL */ str = (char *) PyObject_MALLOC(len + 1); if (str == NULL) { fprintf(stderr, "no mem for next token\n"); err_ret->error = E_NOMEM; break; } if (len > 0) strncpy(str, a, len); str[len] = '\0'; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #endif if (a >= tok->line_start) col_offset = a - tok->line_start; else col_offset = -1; if (type == TYPE_IGNORE) { if (!growable_int_array_add(&type_ignores, tok->lineno)) { err_ret->error = E_NOMEM; break; } continue; } if ((err_ret->error = Ta27Parser_AddToken(ps, (int)type, str, tok->lineno, col_offset, &(err_ret->expected))) != E_OK) { if (err_ret->error != E_DONE) { PyObject_FREE(str); err_ret->token = type; } break; } } if (err_ret->error == E_DONE) { n = ps->p_tree; ps->p_tree = NULL; if (n->n_type == file_input) { /* Put type_ignore nodes in the ENDMARKER of file_input. */ int num; node *ch; size_t i; num = NCH(n); ch = CHILD(n, num - 1); REQ(ch, ENDMARKER); for (i = 0; i < type_ignores.num_items; i++) { Ta27Node_AddChild(ch, TYPE_IGNORE, NULL, type_ignores.items[i], 0); } } growable_int_array_deallocate(&type_ignores); } else n = NULL; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD *flags = ps->p_flags; #endif Ta27Parser_Delete(ps); if (n == NULL) { if (tok->lineno <= 1 && tok->done == E_EOF) err_ret->error = E_EOF; err_ret->lineno = tok->lineno; if (tok->buf != NULL) { char *text = NULL; size_t len; assert(tok->cur - tok->buf < INT_MAX); err_ret->offset = (int)(tok->cur - tok->buf); len = tok->inp - tok->buf; #ifdef Py_USING_UNICODE text = Ta27Tokenizer_RestoreEncoding(tok, len, &err_ret->offset); #endif if (text == NULL) { text = (char *) PyObject_MALLOC(len + 1); if (text != NULL) { if (len > 0) strncpy(text, tok->buf, len); text[len] = '\0'; } } err_ret->text = text; } } else if (tok->encoding != NULL) { /* 'nodes->n_str' uses PyObject_*, while 'tok->encoding' was * allocated using PyMem_ */ node* r = Ta27Node_New(encoding_decl); if (r) r->n_str = PyObject_MALLOC(strlen(tok->encoding)+1); if (!r || !r->n_str) { err_ret->error = E_NOMEM; if (r) PyObject_FREE(r); n = NULL; goto done; } strcpy(r->n_str, tok->encoding); PyMem_FREE(tok->encoding); tok->encoding = NULL; r->n_nchildren = 1; r->n_child = n; n = r; } done: Ta27Tokenizer_Free(tok); return n; } static void initerr(perrdetail *err_ret, const char *filename) { initerr_object(err_ret, PyUnicode_FromString(filename)); } static int initerr_object(perrdetail *err_ret, PyObject *filename) { err_ret->error = E_OK; err_ret->lineno = 0; err_ret->offset = 0; err_ret->text = NULL; err_ret->token = -1; err_ret->expected = -1; #ifndef PGEN if (filename) { Py_INCREF(filename); err_ret->filename = filename; } else { err_ret->filename = PyUnicode_FromString(""); if (err_ret->filename == NULL) { err_ret->error = E_ERROR; return -1; } } #endif return 0; } typed-ast-1.1.0/ast27/Parser/tokenizer.c0000644€Tøžæ€2›s®0000014617413133474673021322 0ustar ddfisher00000000000000 /* Tokenizer implementation */ #include "Python.h" #include "pgenheaders.h" #include #include #include "tokenizer.h" #include "errcode.h" #ifndef PGEN #include "unicodeobject.h" #include "bytesobject.h" #include "fileobject.h" #include "codecs.h" #include "abstract.h" #include "pydebug.h" #endif /* PGEN */ #if PY_MINOR_VERSION >= 4 PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); #else PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, char *); #endif /* Return malloc'ed string including trailing \n; empty malloc'ed string for EOF; NULL if interrupted */ /* Don't ever change this -- it would break the portability of Python code */ #define TABSIZE 8 /* Forward */ static struct tok_state *tok_new(void); static int tok_nextc(struct tok_state *tok); static void tok_backup(struct tok_state *tok, int c); /* Token names */ char *_Ta27Parser_TokenNames[] = { "ENDMARKER", "NAME", "NUMBER", "STRING", "NEWLINE", "INDENT", "DEDENT", "LPAR", "RPAR", "LSQB", "RSQB", "COLON", "COMMA", "SEMI", "PLUS", "MINUS", "STAR", "SLASH", "VBAR", "AMPER", "LESS", "GREATER", "EQUAL", "DOT", "PERCENT", "BACKQUOTE", "LBRACE", "RBRACE", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", "GREATEREQUAL", "TILDE", "CIRCUMFLEX", "LEFTSHIFT", "RIGHTSHIFT", "DOUBLESTAR", "PLUSEQUAL", "MINEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", "DOUBLESTAREQUAL", "DOUBLESLASH", "DOUBLESLASHEQUAL", "AT", /* This table must match the #defines in token.h! */ "OP", "RARROW", "TYPE_IGNORE", "TYPE_COMMENT", "", "" }; /* Spaces in this constant are treated as "zero or more spaces or tabs" when tokenizing. */ static const char* type_comment_prefix = "# type: "; /* Create and initialize a new tok_state structure */ static struct tok_state * tok_new(void) { struct tok_state *tok = (struct tok_state *)PyMem_MALLOC( sizeof(struct tok_state)); if (tok == NULL) return NULL; tok->buf = tok->cur = tok->end = tok->inp = tok->start = NULL; tok->done = E_OK; tok->fp = NULL; tok->input = NULL; tok->tabsize = TABSIZE; tok->indent = 0; tok->indstack[0] = 0; tok->atbol = 1; tok->pendin = 0; tok->prompt = tok->nextprompt = NULL; tok->lineno = 0; tok->level = 0; tok->filename = NULL; tok->altwarning = 0; tok->alterror = 0; tok->alttabsize = 1; tok->altindstack[0] = 0; tok->decoding_state = 0; tok->decoding_erred = 0; tok->read_coding_spec = 0; tok->encoding = NULL; tok->cont_line = 0; #ifndef PGEN tok->decoding_readline = NULL; tok->decoding_buffer = NULL; #endif return tok; } static char * new_string(const char *s, Py_ssize_t len) { char* result = (char *)PyMem_MALLOC(len + 1); if (result != NULL) { memcpy(result, s, len); result[len] = '\0'; } return result; } #ifdef PGEN static char * decoding_fgets(char *s, int size, struct tok_state *tok) { return fgets(s, size, tok->fp); } static int decoding_feof(struct tok_state *tok) { return feof(tok->fp); } static char * decode_str(const char *str, int exec_input, struct tok_state *tok) { return new_string(str, strlen(str)); } #else /* PGEN */ static char * error_ret(struct tok_state *tok) /* XXX */ { tok->decoding_erred = 1; if (tok->fp != NULL && tok->buf != NULL) /* see Ta27Tokenizer_Free */ PyMem_FREE(tok->buf); tok->buf = tok->cur = tok->end = tok->inp = tok->start = NULL; tok->done = E_DECODE; return NULL; /* as if it were EOF */ } static char * get_normal_name(char *s) /* for utf-8 and latin-1 */ { char buf[13]; int i; for (i = 0; i < 12; i++) { int c = s[i]; if (c == '\0') break; else if (c == '_') buf[i] = '-'; else buf[i] = tolower(c); } buf[i] = '\0'; if (strcmp(buf, "utf-8") == 0 || strncmp(buf, "utf-8-", 6) == 0) return "utf-8"; else if (strcmp(buf, "latin-1") == 0 || strcmp(buf, "iso-8859-1") == 0 || strcmp(buf, "iso-latin-1") == 0 || strncmp(buf, "latin-1-", 8) == 0 || strncmp(buf, "iso-8859-1-", 11) == 0 || strncmp(buf, "iso-latin-1-", 12) == 0) return "iso-8859-1"; else return s; } /* Return the coding spec in S, or NULL if none is found. */ static char * get_coding_spec(const char *s, Py_ssize_t size) { Py_ssize_t i; /* Coding spec must be in a comment, and that comment must be * the only statement on the source code line. */ for (i = 0; i < size - 6; i++) { if (s[i] == '#') break; if (s[i] != ' ' && s[i] != '\t' && s[i] != '\014') return NULL; } for (; i < size - 6; i++) { /* XXX inefficient search */ const char* t = s + i; if (strncmp(t, "coding", 6) == 0) { const char* begin = NULL; t += 6; if (t[0] != ':' && t[0] != '=') continue; do { t++; } while (t[0] == '\x20' || t[0] == '\t'); begin = t; while (Py_ISALNUM(t[0]) || t[0] == '-' || t[0] == '_' || t[0] == '.') t++; if (begin < t) { char* r = new_string(begin, t - begin); char* q; if (!r) return NULL; q = get_normal_name(r); if (r != q) { PyMem_FREE(r); r = new_string(q, strlen(q)); } return r; } } } return NULL; } /* Check whether the line contains a coding spec. If it does, invoke the set_readline function for the new encoding. This function receives the tok_state and the new encoding. Return 1 on success, 0 on failure. */ static int check_coding_spec(const char* line, Py_ssize_t size, struct tok_state *tok, int set_readline(struct tok_state *, const char *)) { char * cs; int r = 1; if (tok->cont_line) { /* It's a continuation line, so it can't be a coding spec. */ tok->read_coding_spec = 1; return 1; } cs = get_coding_spec(line, size); if (!cs) { Py_ssize_t i; for (i = 0; i < size; i++) { if (line[i] == '#' || line[i] == '\n' || line[i] == '\r') break; if (line[i] != ' ' && line[i] != '\t' && line[i] != '\014') { /* Stop checking coding spec after a line containing * anything except a comment. */ tok->read_coding_spec = 1; break; } } } else { tok->read_coding_spec = 1; if (tok->encoding == NULL) { assert(tok->decoding_state == 1); /* raw */ if (strcmp(cs, "utf-8") == 0 || strcmp(cs, "iso-8859-1") == 0) { tok->encoding = cs; } else { #ifdef Py_USING_UNICODE r = set_readline(tok, cs); if (r) { tok->encoding = cs; tok->decoding_state = -1; } else { PyErr_Format(PyExc_SyntaxError, "encoding problem: %s", cs); PyMem_FREE(cs); } #else /* Without Unicode support, we cannot process the coding spec. Since there won't be any Unicode literals, that won't matter. */ PyMem_FREE(cs); #endif } } else { /* then, compare cs with BOM */ r = (strcmp(tok->encoding, cs) == 0); if (!r) PyErr_Format(PyExc_SyntaxError, "encoding problem: %s with BOM", cs); PyMem_FREE(cs); } } return r; } /* See whether the file starts with a BOM. If it does, invoke the set_readline function with the new encoding. Return 1 on success, 0 on failure. */ static int check_bom(int get_char(struct tok_state *), void unget_char(int, struct tok_state *), int set_readline(struct tok_state *, const char *), struct tok_state *tok) { int ch1, ch2, ch3; ch1 = get_char(tok); tok->decoding_state = 1; if (ch1 == EOF) { return 1; } else if (ch1 == 0xEF) { ch2 = get_char(tok); if (ch2 != 0xBB) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } ch3 = get_char(tok); if (ch3 != 0xBF) { unget_char(ch3, tok); unget_char(ch2, tok); unget_char(ch1, tok); return 1; } #if 0 /* Disable support for UTF-16 BOMs until a decision is made whether this needs to be supported. */ } else if (ch1 == 0xFE) { ch2 = get_char(tok); if (ch2 != 0xFF) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } if (!set_readline(tok, "utf-16-be")) return 0; tok->decoding_state = -1; } else if (ch1 == 0xFF) { ch2 = get_char(tok); if (ch2 != 0xFE) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } if (!set_readline(tok, "utf-16-le")) return 0; tok->decoding_state = -1; #endif } else { unget_char(ch1, tok); return 1; } if (tok->encoding != NULL) PyMem_FREE(tok->encoding); tok->encoding = new_string("utf-8", 5); /* resulting is in utf-8 */ return 1; } /* Read a line of text from TOK into S, using the stream in TOK. Return NULL on failure, else S. On entry, tok->decoding_buffer will be one of: 1) NULL: need to call tok->decoding_readline to get a new line 2) PyUnicodeObject *: decoding_feof has called tok->decoding_readline and stored the result in tok->decoding_buffer 3) PyBytesObject *: previous call to fp_readl did not have enough room (in the s buffer) to copy entire contents of the line read by tok->decoding_readline. tok->decoding_buffer has the overflow. In this case, fp_readl is called in a loop (with an expanded buffer) until the buffer ends with a '\n' (or until the end of the file is reached): see tok_nextc and its calls to decoding_fgets. */ static char * fp_readl(char *s, int size, struct tok_state *tok) { #ifndef Py_USING_UNICODE /* In a non-Unicode built, this should never be called. */ Py_FatalError("fp_readl should not be called in this build."); return NULL; /* Keep compiler happy (not reachable) */ #else PyObject* utf8 = NULL; PyObject* buf = tok->decoding_buffer; char *str; Py_ssize_t utf8len; /* Ask for one less byte so we can terminate it */ assert(size > 0); size--; if (buf == NULL) { buf = PyObject_CallObject(tok->decoding_readline, NULL); if (buf == NULL) return error_ret(tok); if (!PyUnicode_Check(buf)) { Py_DECREF(buf); PyErr_SetString(PyExc_SyntaxError, "codec did not return a unicode object"); return error_ret(tok); } } else { tok->decoding_buffer = NULL; if (PyBytes_CheckExact(buf)) utf8 = buf; } if (utf8 == NULL) { utf8 = PyUnicode_AsUTF8String(buf); Py_DECREF(buf); if (utf8 == NULL) return error_ret(tok); } str = PyBytes_AsString(utf8); utf8len = PyBytes_GET_SIZE(utf8); if (utf8len > size) { tok->decoding_buffer = PyBytes_FromStringAndSize(str+size, utf8len-size); if (tok->decoding_buffer == NULL) { Py_DECREF(utf8); return error_ret(tok); } utf8len = size; } memcpy(s, str, utf8len); s[utf8len] = '\0'; Py_DECREF(utf8); if (utf8len == 0) return NULL; /* EOF */ return s; #endif } /* Set the readline function for TOK to a StreamReader's readline function. The StreamReader is named ENC. This function is called from check_bom and check_coding_spec. ENC is usually identical to the future value of tok->encoding, except for the (currently unsupported) case of UTF-16. Return 1 on success, 0 on failure. */ /* taken from Python 3.5.1 */ static int fp_setreadl(struct tok_state *tok, const char* enc) { PyObject *readline = NULL, *stream = NULL, *io = NULL; _Py_IDENTIFIER(open); _Py_IDENTIFIER(readline); int fd; long pos; io = PyImport_ImportModuleNoBlock("io"); if (io == NULL) goto cleanup; fd = fileno(tok->fp); /* Due to buffering the file offset for fd can be different from the file * position of tok->fp. If tok->fp was opened in text mode on Windows, * its file position counts CRLF as one char and can't be directly mapped * to the file offset for fd. Instead we step back one byte and read to * the end of line.*/ pos = ftell(tok->fp); if (pos == -1 || lseek(fd, (off_t)(pos > 0 ? pos - 1 : pos), SEEK_SET) == (off_t)-1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, NULL); goto cleanup; } stream = _PyObject_CallMethodId(io, &PyId_open, "isisOOO", fd, "r", -1, enc, Py_None, Py_None, Py_False); if (stream == NULL) goto cleanup; Py_XDECREF(tok->decoding_readline); readline = _PyObject_GetAttrId(stream, &PyId_readline); tok->decoding_readline = readline; if (pos > 0) { if (PyObject_CallObject(readline, NULL) == NULL) { readline = NULL; goto cleanup; } } cleanup: Py_XDECREF(stream); Py_XDECREF(io); return readline != NULL; } /* Fetch the next byte from TOK. */ static int fp_getc(struct tok_state *tok) { return getc(tok->fp); } /* Unfetch the last byte back into TOK. */ static void fp_ungetc(int c, struct tok_state *tok) { ungetc(c, tok->fp); } /* Read a line of input from TOK. Determine encoding if necessary. */ static char * decoding_fgets(char *s, int size, struct tok_state *tok) { char *line = NULL; int badchar = 0; for (;;) { if (tok->decoding_state < 0) { /* We already have a codec associated with this input. */ line = fp_readl(s, size, tok); break; } else if (tok->decoding_state > 0) { /* We want a 'raw' read. */ line = Py_UniversalNewlineFgets(s, size, tok->fp, NULL); break; } else { /* We have not yet determined the encoding. If an encoding is found, use the file-pointer reader functions from now on. */ if (!check_bom(fp_getc, fp_ungetc, fp_setreadl, tok)) return error_ret(tok); assert(tok->decoding_state != 0); } } if (line != NULL && tok->lineno < 2 && !tok->read_coding_spec) { if (!check_coding_spec(line, strlen(line), tok, fp_setreadl)) { return error_ret(tok); } } #ifndef PGEN /* The default encoding is ASCII, so make sure we don't have any non-ASCII bytes in it. */ if (line && !tok->encoding) { unsigned char *c; for (c = (unsigned char *)line; *c; c++) if (*c > 127) { badchar = *c; break; } } if (badchar) { char buf[500]; /* Need to add 1 to the line number, since this line has not been counted, yet. */ sprintf(buf, "Non-ASCII character '\\x%.2x' " "in file %.200s on line %i, " "but no encoding declared; " "see http://python.org/dev/peps/pep-0263/ for details", badchar, tok->filename, tok->lineno + 1); PyErr_SetString(PyExc_SyntaxError, buf); return error_ret(tok); } #endif return line; } static int decoding_feof(struct tok_state *tok) { if (tok->decoding_state >= 0) { return feof(tok->fp); } else { PyObject* buf = tok->decoding_buffer; if (buf == NULL) { buf = PyObject_CallObject(tok->decoding_readline, NULL); if (buf == NULL) { error_ret(tok); return 1; } else { tok->decoding_buffer = buf; } } return PyObject_Length(buf) == 0; } } /* Fetch a byte from TOK, using the string buffer. */ static int buf_getc(struct tok_state *tok) { return Py_CHARMASK(*tok->str++); } /* Unfetch a byte from TOK, using the string buffer. */ static void buf_ungetc(int c, struct tok_state *tok) { tok->str--; assert(Py_CHARMASK(*tok->str) == c); /* tok->cur may point to read-only segment */ } /* Set the readline function for TOK to ENC. For the string-based tokenizer, this means to just record the encoding. */ static int buf_setreadl(struct tok_state *tok, const char* enc) { tok->enc = enc; return 1; } /* Return a UTF-8 encoding Python string object from the C byte string STR, which is encoded with ENC. */ #ifdef Py_USING_UNICODE static PyObject * translate_into_utf8(const char* str, const char* enc) { PyObject *utf8; PyObject* buf = PyUnicode_Decode(str, strlen(str), enc, NULL); if (buf == NULL) return NULL; utf8 = PyUnicode_AsUTF8String(buf); Py_DECREF(buf); return utf8; } #endif static char * translate_newlines(const char *s, int exec_input, struct tok_state *tok) { int skip_next_lf = 0, needed_length = strlen(s) + 2, final_length; char *buf, *current; char c = '\0'; buf = PyMem_MALLOC(needed_length); if (buf == NULL) { tok->done = E_NOMEM; return NULL; } for (current = buf; *s; s++, current++) { c = *s; if (skip_next_lf) { skip_next_lf = 0; if (c == '\n') { c = *++s; if (!c) break; } } if (c == '\r') { skip_next_lf = 1; c = '\n'; } *current = c; } /* If this is exec input, add a newline to the end of the string if there isn't one already. */ if (exec_input && c != '\n') { *current = '\n'; current++; } *current = '\0'; final_length = current - buf + 1; if (final_length < needed_length && final_length) /* should never fail */ buf = PyMem_REALLOC(buf, final_length); return buf; } /* Decode a byte string STR for use as the buffer of TOK. Look for encoding declarations inside STR, and record them inside TOK. */ static const char * decode_str(const char *input, int single, struct tok_state *tok) { PyObject* utf8 = NULL; const char *str; const char *s; const char *newl[2] = {NULL, NULL}; int lineno = 0; tok->input = str = translate_newlines(input, single, tok); if (str == NULL) return NULL; tok->enc = NULL; tok->str = str; if (!check_bom(buf_getc, buf_ungetc, buf_setreadl, tok)) return error_ret(tok); str = tok->str; /* string after BOM if any */ assert(str); #ifdef Py_USING_UNICODE if (tok->enc != NULL) { utf8 = translate_into_utf8(str, tok->enc); if (utf8 == NULL) return error_ret(tok); str = PyBytes_AsString(utf8); } #endif for (s = str;; s++) { if (*s == '\0') break; else if (*s == '\n') { assert(lineno < 2); newl[lineno] = s; lineno++; if (lineno == 2) break; } } tok->enc = NULL; /* need to check line 1 and 2 separately since check_coding_spec assumes a single line as input */ if (newl[0]) { if (!check_coding_spec(str, newl[0] - str, tok, buf_setreadl)) return error_ret(tok); if (tok->enc == NULL && !tok->read_coding_spec && newl[1]) { if (!check_coding_spec(newl[0]+1, newl[1] - newl[0], tok, buf_setreadl)) return error_ret(tok); } } #ifdef Py_USING_UNICODE if (tok->enc != NULL) { assert(utf8 == NULL); utf8 = translate_into_utf8(str, tok->enc); if (utf8 == NULL) return error_ret(tok); str = PyBytes_AsString(utf8); } #endif assert(tok->decoding_buffer == NULL); tok->decoding_buffer = utf8; /* CAUTION */ return str; } #endif /* PGEN */ /* Set up tokenizer for string */ struct tok_state * Ta27Tokenizer_FromString(const char *str, int exec_input) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; str = (char *)decode_str(str, exec_input, tok); if (str == NULL) { Ta27Tokenizer_Free(tok); return NULL; } /* XXX: constify members. */ tok->buf = tok->cur = tok->end = tok->inp = (char*)str; return tok; } /* adapted from Python 3.5.1 */ struct tok_state * Ta27Tokenizer_FromUTF8(const char *str, int exec_input) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; #ifndef PGEN tok->input = str = translate_newlines(str, exec_input, tok); #endif if (str == NULL) { Ta27Tokenizer_Free(tok); return NULL; } tok->decoding_state = 1; tok->read_coding_spec = 1; tok->enc = NULL; tok->str = str; /* XXX: constify members. */ tok->buf = tok->cur = tok->end = tok->inp = (char*)str; return tok; } /* Set up tokenizer for file */ struct tok_state * Ta27Tokenizer_FromFile(FILE *fp, char *ps1, char *ps2) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; if ((tok->buf = (char *)PyMem_MALLOC(BUFSIZ)) == NULL) { Ta27Tokenizer_Free(tok); return NULL; } tok->cur = tok->inp = tok->buf; tok->end = tok->buf + BUFSIZ; tok->fp = fp; tok->prompt = ps1; tok->nextprompt = ps2; return tok; } /* Free a tok_state structure */ void Ta27Tokenizer_Free(struct tok_state *tok) { if (tok->encoding != NULL) PyMem_FREE(tok->encoding); #ifndef PGEN Py_XDECREF(tok->decoding_readline); Py_XDECREF(tok->decoding_buffer); #endif if (tok->fp != NULL && tok->buf != NULL) PyMem_FREE(tok->buf); if (tok->input) PyMem_FREE((char *)tok->input); PyMem_FREE(tok); } /* Get next char, updating state; error code goes into tok->done */ /* taken from Python 3.5.1 */ static int tok_nextc(struct tok_state *tok) { for (;;) { if (tok->cur != tok->inp) { return Py_CHARMASK(*tok->cur++); /* Fast path */ } if (tok->done != E_OK) return EOF; if (tok->fp == NULL) { char *end = strchr(tok->inp, '\n'); if (end != NULL) end++; else { end = strchr(tok->inp, '\0'); if (end == tok->inp) { tok->done = E_EOF; return EOF; } } if (tok->start == NULL) tok->buf = tok->cur; tok->line_start = tok->cur; tok->lineno++; tok->inp = end; return Py_CHARMASK(*tok->cur++); } if (tok->prompt != NULL) { char *newtok = PyOS_Readline(stdin, stdout, tok->prompt); #ifndef PGEN if (newtok != NULL) { char *translated = translate_newlines(newtok, 0, tok); PyMem_FREE(newtok); if (translated == NULL) return EOF; newtok = translated; } if (tok->encoding && newtok && *newtok) { /* Recode to UTF-8 */ Py_ssize_t buflen; const char* buf; PyObject *u = translate_into_utf8(newtok, tok->encoding); PyMem_FREE(newtok); if (!u) { tok->done = E_DECODE; return EOF; } buflen = PyBytes_GET_SIZE(u); buf = PyBytes_AS_STRING(u); newtok = PyMem_MALLOC(buflen+1); strcpy(newtok, buf); Py_DECREF(u); } #endif if (tok->nextprompt != NULL) tok->prompt = tok->nextprompt; if (newtok == NULL) tok->done = E_INTR; else if (*newtok == '\0') { PyMem_FREE(newtok); tok->done = E_EOF; } else if (tok->start != NULL) { size_t start = tok->start - tok->buf; size_t oldlen = tok->cur - tok->buf; size_t newlen = oldlen + strlen(newtok); char *buf = tok->buf; buf = (char *)PyMem_REALLOC(buf, newlen+1); tok->lineno++; if (buf == NULL) { PyMem_FREE(tok->buf); tok->buf = NULL; PyMem_FREE(newtok); tok->done = E_NOMEM; return EOF; } tok->buf = buf; tok->cur = tok->buf + oldlen; tok->line_start = tok->cur; strcpy(tok->buf + oldlen, newtok); PyMem_FREE(newtok); tok->inp = tok->buf + newlen; tok->end = tok->inp + 1; tok->start = tok->buf + start; } else { tok->lineno++; if (tok->buf != NULL) PyMem_FREE(tok->buf); tok->buf = newtok; tok->cur = tok->buf; tok->line_start = tok->buf; tok->inp = strchr(tok->buf, '\0'); tok->end = tok->inp + 1; } } else { int done = 0; Py_ssize_t cur = 0; char *pt; if (tok->start == NULL) { if (tok->buf == NULL) { tok->buf = (char *) PyMem_MALLOC(BUFSIZ); if (tok->buf == NULL) { tok->done = E_NOMEM; return EOF; } tok->end = tok->buf + BUFSIZ; } if (decoding_fgets(tok->buf, (int)(tok->end - tok->buf), tok) == NULL) { if (!tok->decoding_erred) tok->done = E_EOF; done = 1; } else { tok->done = E_OK; tok->inp = strchr(tok->buf, '\0'); done = tok->inp[-1] == '\n'; } } else { cur = tok->cur - tok->buf; if (decoding_feof(tok)) { tok->done = E_EOF; done = 1; } else tok->done = E_OK; } tok->lineno++; /* Read until '\n' or EOF */ while (!done) { Py_ssize_t curstart = tok->start == NULL ? -1 : tok->start - tok->buf; Py_ssize_t curvalid = tok->inp - tok->buf; Py_ssize_t newsize = curvalid + BUFSIZ; char *newbuf = tok->buf; newbuf = (char *)PyMem_REALLOC(newbuf, newsize); if (newbuf == NULL) { tok->done = E_NOMEM; tok->cur = tok->inp; return EOF; } tok->buf = newbuf; tok->cur = tok->buf + cur; tok->line_start = tok->cur; tok->inp = tok->buf + curvalid; tok->end = tok->buf + newsize; tok->start = curstart < 0 ? NULL : tok->buf + curstart; if (decoding_fgets(tok->inp, (int)(tok->end - tok->inp), tok) == NULL) { /* Break out early on decoding errors, as tok->buf will be NULL */ if (tok->decoding_erred) return EOF; /* Last line does not end in \n, fake one */ strcpy(tok->inp, "\n"); } tok->inp = strchr(tok->inp, '\0'); done = tok->inp[-1] == '\n'; } if (tok->buf != NULL) { tok->cur = tok->buf + cur; tok->line_start = tok->cur; /* replace "\r\n" with "\n" */ /* For Mac leave the \r, giving a syntax error */ pt = tok->inp - 2; if (pt >= tok->buf && *pt == '\r') { *pt++ = '\n'; *pt = '\0'; tok->inp = pt; } } } if (tok->done != E_OK) { if (tok->prompt != NULL) PySys_WriteStderr("\n"); tok->cur = tok->inp; return EOF; } } /*NOTREACHED*/ } /* Back-up one character */ static void tok_backup(register struct tok_state *tok, register int c) { if (c != EOF) { if (--tok->cur < tok->buf) Py_FatalError("tok_backup: beginning of buffer"); if (*tok->cur != c) *tok->cur = c; } } /* Return the token corresponding to a single character */ int Ta27Token_OneChar(int c) { switch (c) { case '(': return LPAR; case ')': return RPAR; case '[': return LSQB; case ']': return RSQB; case ':': return COLON; case ',': return COMMA; case ';': return SEMI; case '+': return PLUS; case '-': return MINUS; case '*': return STAR; case '/': return SLASH; case '|': return VBAR; case '&': return AMPER; case '<': return LESS; case '>': return GREATER; case '=': return EQUAL; case '.': return DOT; case '%': return PERCENT; case '`': return BACKQUOTE; case '{': return LBRACE; case '}': return RBRACE; case '^': return CIRCUMFLEX; case '~': return TILDE; case '@': return AT; default: return OP; } } int Ta27Token_TwoChars(int c1, int c2) { switch (c1) { case '=': switch (c2) { case '=': return EQEQUAL; } break; case '!': switch (c2) { case '=': return NOTEQUAL; } break; case '<': switch (c2) { case '>': return NOTEQUAL; case '=': return LESSEQUAL; case '<': return LEFTSHIFT; } break; case '>': switch (c2) { case '=': return GREATEREQUAL; case '>': return RIGHTSHIFT; } break; case '+': switch (c2) { case '=': return PLUSEQUAL; } break; case '-': switch (c2) { case '=': return MINEQUAL; case '>': return RARROW; } break; case '*': switch (c2) { case '*': return DOUBLESTAR; case '=': return STAREQUAL; } break; case '/': switch (c2) { case '/': return DOUBLESLASH; case '=': return SLASHEQUAL; } break; case '|': switch (c2) { case '=': return VBAREQUAL; } break; case '%': switch (c2) { case '=': return PERCENTEQUAL; } break; case '&': switch (c2) { case '=': return AMPEREQUAL; } break; case '^': switch (c2) { case '=': return CIRCUMFLEXEQUAL; } break; } return OP; } int Ta27Token_ThreeChars(int c1, int c2, int c3) { switch (c1) { case '<': switch (c2) { case '<': switch (c3) { case '=': return LEFTSHIFTEQUAL; } break; } break; case '>': switch (c2) { case '>': switch (c3) { case '=': return RIGHTSHIFTEQUAL; } break; } break; case '*': switch (c2) { case '*': switch (c3) { case '=': return DOUBLESTAREQUAL; } break; } break; case '/': switch (c2) { case '/': switch (c3) { case '=': return DOUBLESLASHEQUAL; } break; } break; } return OP; } static int indenterror(struct tok_state *tok) { if (tok->alterror) { tok->done = E_TABSPACE; tok->cur = tok->inp; return 1; } if (tok->altwarning) { PySys_WriteStderr("%s: inconsistent use of tabs and spaces " "in indentation\n", tok->filename); tok->altwarning = 0; } return 0; } /* Get next token, after space stripping etc. */ static int tok_get(register struct tok_state *tok, char **p_start, char **p_end) { register int c; int blankline; *p_start = *p_end = NULL; nextline: tok->start = NULL; blankline = 0; /* Get indentation level */ if (tok->atbol) { register int col = 0; register int altcol = 0; tok->atbol = 0; for (;;) { c = tok_nextc(tok); if (c == ' ') col++, altcol++; else if (c == '\t') { col = (col/tok->tabsize + 1) * tok->tabsize; altcol = (altcol/tok->alttabsize + 1) * tok->alttabsize; } else if (c == '\014') /* Control-L (formfeed) */ col = altcol = 0; /* For Emacs users */ else break; } tok_backup(tok, c); if (c == '#' || c == '\n') { /* Lines with only whitespace and/or comments shouldn't affect the indentation and are not passed to the parser as NEWLINE tokens, except *totally* empty lines in interactive mode, which signal the end of a command group. */ if (col == 0 && c == '\n' && tok->prompt != NULL) blankline = 0; /* Let it through */ else blankline = 1; /* Ignore completely */ /* We can't jump back right here since we still may need to skip to the end of a comment */ } if (!blankline && tok->level == 0) { if (col == tok->indstack[tok->indent]) { /* No change */ if (altcol != tok->altindstack[tok->indent]) { if (indenterror(tok)) return ERRORTOKEN; } } else if (col > tok->indstack[tok->indent]) { /* Indent -- always one */ if (tok->indent+1 >= MAXINDENT) { tok->done = E_TOODEEP; tok->cur = tok->inp; return ERRORTOKEN; } if (altcol <= tok->altindstack[tok->indent]) { if (indenterror(tok)) return ERRORTOKEN; } tok->pendin++; tok->indstack[++tok->indent] = col; tok->altindstack[tok->indent] = altcol; } else /* col < tok->indstack[tok->indent] */ { /* Dedent -- any number, must be consistent */ while (tok->indent > 0 && col < tok->indstack[tok->indent]) { tok->pendin--; tok->indent--; } if (col != tok->indstack[tok->indent]) { tok->done = E_DEDENT; tok->cur = tok->inp; return ERRORTOKEN; } if (altcol != tok->altindstack[tok->indent]) { if (indenterror(tok)) return ERRORTOKEN; } } } } tok->start = tok->cur; /* Return pending indents/dedents */ if (tok->pendin != 0) { if (tok->pendin < 0) { tok->pendin++; return DEDENT; } else { tok->pendin--; return INDENT; } } again: tok->start = NULL; /* Skip spaces */ do { c = tok_nextc(tok); } while (c == ' ' || c == '\t' || c == '\014'); /* Set start of current token */ tok->start = tok->cur - 1; /* Skip comment, while looking for tab-setting magic and type comments */ if (c == '#') { static char *tabforms[] = { "tab-width:", /* Emacs */ ":tabstop=", /* vim, full form */ ":ts=", /* vim, abbreviated form */ "set tabsize=", /* will vi never die? */ /* more templates can be added here to support other editors */ }; char cbuf[80]; char *tp, **cp; /* used for type comment checks */ const char *prefix, *p, *type_start; tp = cbuf; do { *tp++ = c = tok_nextc(tok); } while (c != EOF && c != '\n' && (size_t)(tp - cbuf + 1) < sizeof(cbuf)); *tp = '\0'; for (cp = tabforms; cp < tabforms + sizeof(tabforms)/sizeof(tabforms[0]); cp++) { if ((tp = strstr(cbuf, *cp))) { int newsize = atoi(tp + strlen(*cp)); if (newsize >= 1 && newsize <= 40) { tok->tabsize = newsize; if (Py_VerboseFlag) PySys_WriteStderr( "Tab size set to %d\n", newsize); } } } while (c != EOF && c != '\n') c = tok_nextc(tok); /* check for type comment */ p = tok->start; prefix = type_comment_prefix; while (*prefix && p < tok->cur) { if (*prefix == ' ') { while (*p == ' ' || *p == '\t') p++; } else if (*prefix == *p) { p++; } else { break; } prefix++; } /* This is a type comment if we matched all of type_comment_prefix. */ if (!*prefix) { int is_type_ignore = 1; tok_backup(tok, c); /* don't eat the newline or EOF */ type_start = p; is_type_ignore = tok->cur >= p + 6 && memcmp(p, "ignore", 6) == 0; p += 6; while (is_type_ignore && p < tok->cur) { if (*p == '#') break; is_type_ignore = is_type_ignore && (*p == ' ' || *p == '\t'); p++; } if (is_type_ignore) { /* If this type ignore is the only thing on the line, consume the newline also. */ if (blankline) { tok_nextc(tok); tok->atbol = 1; } return TYPE_IGNORE; } else { *p_start = (char *) type_start; /* after type_comment_prefix */ *p_end = tok->cur; return TYPE_COMMENT; } } } /* Check for EOF and errors now */ if (c == EOF) { return tok->done == E_EOF ? ENDMARKER : ERRORTOKEN; } /* Identifier (most frequent token!) */ if (Py_ISALPHA(c) || c == '_') { /* Process r"", u"" and ur"" */ switch (c) { case 'b': case 'B': c = tok_nextc(tok); if (c == 'r' || c == 'R') c = tok_nextc(tok); if (c == '"' || c == '\'') goto letter_quote; break; case 'r': case 'R': c = tok_nextc(tok); if (c == '"' || c == '\'') goto letter_quote; break; case 'u': case 'U': c = tok_nextc(tok); if (c == 'r' || c == 'R') c = tok_nextc(tok); if (c == '"' || c == '\'') goto letter_quote; break; } while (c != EOF && (Py_ISALNUM(c) || c == '_')) { c = tok_nextc(tok); } tok_backup(tok, c); *p_start = tok->start; *p_end = tok->cur; return NAME; } /* Newline */ if (c == '\n') { tok->atbol = 1; if (blankline || tok->level > 0) goto nextline; *p_start = tok->start; *p_end = tok->cur - 1; /* Leave '\n' out of the string */ tok->cont_line = 0; return NEWLINE; } /* Period or number starting with period? */ if (c == '.') { c = tok_nextc(tok); if (isdigit(c)) { goto fraction; } else { tok_backup(tok, c); *p_start = tok->start; *p_end = tok->cur; return DOT; } } /* Number */ if (isdigit(c)) { if (c == '0') { /* Hex, octal or binary -- maybe. */ c = tok_nextc(tok); if (c == '.') goto fraction; #ifndef WITHOUT_COMPLEX if (c == 'j' || c == 'J') goto imaginary; #endif if (c == 'x' || c == 'X') { /* Hex */ c = tok_nextc(tok); if (!isxdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while (isxdigit(c)); } else if (c == 'o' || c == 'O') { /* Octal */ c = tok_nextc(tok); if (c < '0' || c >= '8') { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while ('0' <= c && c < '8'); } else if (c == 'b' || c == 'B') { /* Binary */ c = tok_nextc(tok); if (c != '0' && c != '1') { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while (c == '0' || c == '1'); } else { int found_decimal = 0; /* Octal; c is first char of it */ /* There's no 'isoctdigit' macro, sigh */ while ('0' <= c && c < '8') { c = tok_nextc(tok); } if (isdigit(c)) { found_decimal = 1; do { c = tok_nextc(tok); } while (isdigit(c)); } if (c == '.') goto fraction; else if (c == 'e' || c == 'E') goto exponent; #ifndef WITHOUT_COMPLEX else if (c == 'j' || c == 'J') goto imaginary; #endif else if (found_decimal) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } } if (c == 'l' || c == 'L') c = tok_nextc(tok); } else { /* Decimal */ do { c = tok_nextc(tok); } while (isdigit(c)); if (c == 'l' || c == 'L') c = tok_nextc(tok); else { /* Accept floating point numbers. */ if (c == '.') { fraction: /* Fraction */ do { c = tok_nextc(tok); } while (isdigit(c)); } if (c == 'e' || c == 'E') { int e; exponent: e = c; /* Exponent part */ c = tok_nextc(tok); if (c == '+' || c == '-') { c = tok_nextc(tok); if (!isdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } } else if (!isdigit(c)) { tok_backup(tok, c); tok_backup(tok, e); *p_start = tok->start; *p_end = tok->cur; return NUMBER; } do { c = tok_nextc(tok); } while (isdigit(c)); } #ifndef WITHOUT_COMPLEX if (c == 'j' || c == 'J') /* Imaginary part */ imaginary: c = tok_nextc(tok); #endif } } tok_backup(tok, c); *p_start = tok->start; *p_end = tok->cur; return NUMBER; } letter_quote: /* String */ if (c == '\'' || c == '"') { Py_ssize_t quote2 = tok->cur - tok->start + 1; int quote = c; int triple = 0; int tripcount = 0; for (;;) { c = tok_nextc(tok); if (c == '\n') { if (!triple) { tok->done = E_EOLS; tok_backup(tok, c); return ERRORTOKEN; } tripcount = 0; tok->cont_line = 1; /* multiline string. */ } else if (c == EOF) { if (triple) tok->done = E_EOFS; else tok->done = E_EOLS; tok->cur = tok->inp; return ERRORTOKEN; } else if (c == quote) { tripcount++; if (tok->cur - tok->start == quote2) { c = tok_nextc(tok); if (c == quote) { triple = 1; tripcount = 0; continue; } tok_backup(tok, c); } if (!triple || tripcount == 3) break; } else if (c == '\\') { tripcount = 0; c = tok_nextc(tok); if (c == EOF) { tok->done = E_EOLS; tok->cur = tok->inp; return ERRORTOKEN; } } else tripcount = 0; } *p_start = tok->start; *p_end = tok->cur; return STRING; } /* Line continuation */ if (c == '\\') { c = tok_nextc(tok); if (c != '\n') { tok->done = E_LINECONT; tok->cur = tok->inp; return ERRORTOKEN; } tok->cont_line = 1; goto again; /* Read next line */ } /* Check for two-character token */ { int c2 = tok_nextc(tok); int token = Ta27Token_TwoChars(c, c2); #ifndef PGEN if (token == NOTEQUAL && c == '<') { if (PyErr_WarnExplicit(PyExc_DeprecationWarning, "<> not supported in 3.x; use !=", tok->filename, tok->lineno, NULL, NULL)) { return ERRORTOKEN; } } #endif if (token != OP) { int c3 = tok_nextc(tok); int token3 = Ta27Token_ThreeChars(c, c2, c3); if (token3 != OP) { token = token3; } else { tok_backup(tok, c3); } *p_start = tok->start; *p_end = tok->cur; return token; } tok_backup(tok, c2); } /* Keep track of parentheses nesting level */ switch (c) { case '(': case '[': case '{': tok->level++; break; case ')': case ']': case '}': tok->level--; break; } /* Punctuation character */ *p_start = tok->start; *p_end = tok->cur; return Ta27Token_OneChar(c); } int Ta27Tokenizer_Get(struct tok_state *tok, char **p_start, char **p_end) { int result = tok_get(tok, p_start, p_end); if (tok->decoding_erred) { result = ERRORTOKEN; tok->done = E_DECODE; } return result; } /* This function is only called from parsetok. However, it cannot live there, as it must be empty for PGEN, and we can check for PGEN only in this file. */ #if defined(PGEN) || !defined(Py_USING_UNICODE) char* Ta27Tokenizer_RestoreEncoding(struct tok_state* tok, int len, int* offset) { return NULL; } #else #ifdef Py_USING_UNICODE static PyObject * dec_utf8(const char *enc, const char *text, size_t len) { PyObject *ret = NULL; PyObject *unicode_text = PyUnicode_DecodeUTF8(text, len, "replace"); if (unicode_text) { ret = PyUnicode_AsEncodedString(unicode_text, enc, "replace"); Py_DECREF(unicode_text); } if (!ret) { PyErr_Clear(); } return ret; } char * Ta27Tokenizer_RestoreEncoding(struct tok_state* tok, int len, int *offset) { char *text = NULL; if (tok->encoding) { /* convert source to original encondig */ PyObject *lineobj = dec_utf8(tok->encoding, tok->buf, len); if (lineobj != NULL) { int linelen = PyBytes_Size(lineobj); const char *line = PyBytes_AsString(lineobj); text = PyObject_MALLOC(linelen + 1); if (text != NULL && line != NULL) { if (linelen) strncpy(text, line, linelen); text[linelen] = '\0'; } Py_DECREF(lineobj); /* adjust error offset */ if (*offset > 1) { PyObject *offsetobj = dec_utf8(tok->encoding, tok->buf, *offset-1); if (offsetobj) { *offset = PyBytes_Size(offsetobj) + 1; Py_DECREF(offsetobj); } } } } return text; } #endif /* defined(Py_USING_UNICODE) */ #endif #ifdef Py_DEBUG void tok_dump(int type, char *start, char *end) { printf("%s", _Ta27Parser_TokenNames[type]); if (type == NAME || type == NUMBER || type == STRING || type == OP) printf("(%.*s)", (int)(end - start), start); } #endif typed-ast-1.1.0/ast27/Parser/tokenizer.h0000644€Tøžæ€2›s®0000000574013050216645021307 0ustar ddfisher00000000000000#ifndef Ta27_TOKENIZER_H #define Ta27_TOKENIZER_H #ifdef __cplusplus extern "C" { #endif #include "object.h" /* Tokenizer interface */ #include "token.h" /* For token types */ #define MAXINDENT 100 /* Max indentation level */ /* Tokenizer state */ struct tok_state { /* Input state; buf <= cur <= inp <= end */ /* NB an entire line is held in the buffer */ char *buf; /* Input buffer, or NULL; malloc'ed if fp != NULL */ char *cur; /* Next character in buffer */ char *inp; /* End of data in buffer */ char *end; /* End of input buffer if buf != NULL */ char *start; /* Start of current token if not NULL */ int done; /* E_OK normally, E_EOF at EOF, otherwise error code */ /* NB If done != E_OK, cur must be == inp!!! */ FILE *fp; /* Rest of input; NULL if tokenizing a string */ int tabsize; /* Tab spacing */ int indent; /* Current indentation index */ int indstack[MAXINDENT]; /* Stack of indents */ int atbol; /* Nonzero if at begin of new line */ int pendin; /* Pending indents (if > 0) or dedents (if < 0) */ char *prompt, *nextprompt; /* For interactive prompting */ int lineno; /* Current line number */ int level; /* () [] {} Parentheses nesting level */ /* Used to allow free continuations inside them */ /* Stuff for checking on different tab sizes */ const char *filename; /* For error messages */ int altwarning; /* Issue warning if alternate tabs don't match */ int alterror; /* Issue error if alternate tabs don't match */ int alttabsize; /* Alternate tab spacing */ int altindstack[MAXINDENT]; /* Stack of alternate indents */ /* Stuff for PEP 0263 */ int decoding_state; /* -1:decoding, 0:init, 1:raw */ int decoding_erred; /* whether erred in decoding */ int read_coding_spec; /* whether 'coding:...' has been read */ char *encoding; int cont_line; /* whether we are in a continuation line. */ const char* line_start; /* pointer to start of current line */ #ifndef PGEN PyObject *decoding_readline; /* codecs.open(...).readline */ PyObject *decoding_buffer; #endif const char* enc; const char* str; const char* input; /* Tokenizer's newline translated copy of the string. */ }; extern struct tok_state *Ta27Tokenizer_FromString(const char *, int); extern struct tok_state *Ta27Tokenizer_FromUTF8(const char *, int); extern struct tok_state *Ta27Tokenizer_FromFile(FILE *, char *, char *); extern void Ta27Tokenizer_Free(struct tok_state *); extern int Ta27Tokenizer_Get(struct tok_state *, char **, char **); #if defined(PGEN) || defined(Py_USING_UNICODE) extern char * Ta27Tokenizer_RestoreEncoding(struct tok_state* tok, int len, int *offset); #endif #ifdef __cplusplus } #endif #endif /* !Ta27_TOKENIZER_H */ typed-ast-1.1.0/ast27/Python/0000755€Tøžæ€2›s®0000000000013133476735017155 5ustar ddfisher00000000000000typed-ast-1.1.0/ast27/Python/asdl.c0000644€Tøžæ€2›s®0000000263213050216645020235 0ustar ddfisher00000000000000#include "Python.h" #include "asdl.h" asdl_seq * _Py_asdl_seq_new(Py_ssize_t size, PyArena *arena) { asdl_seq *seq = NULL; size_t n; /* check size is sane */ if (size < 0 || (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > PY_SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } n += sizeof(asdl_seq); seq = (asdl_seq *)PyArena_Malloc(arena, n); if (!seq) { PyErr_NoMemory(); return NULL; } memset(seq, 0, n); seq->size = size; return seq; } asdl_int_seq * _Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena) { asdl_int_seq *seq = NULL; size_t n; /* check size is sane */ if (size < 0 || (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > PY_SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } n += sizeof(asdl_seq); seq = (asdl_int_seq *)PyArena_Malloc(arena, n); if (!seq) { PyErr_NoMemory(); return NULL; } memset(seq, 0, n); seq->size = size; return seq; } typed-ast-1.1.0/ast27/Python/ast.c0000644€Tøžæ€2›s®0000034565113133474673020125 0ustar ddfisher00000000000000/* * This file includes functions to transform a concrete syntax tree (CST) to * an abstract syntax tree (AST). The main function is Ta27AST_FromNode(). * */ #include "Python.h" #include "Python-ast.h" #include "grammar.h" #include "node.h" #include "pyarena.h" #include "ast.h" #include "token.h" #include "parsetok.h" #include "graminit.h" #include "unicodeobject.h" #include /* Data structure used internally */ struct compiling { char *c_encoding; /* source encoding */ int c_future_unicode; /* __future__ unicode literals flag */ PyArena *c_arena; /* arena for allocating memeory */ const char *c_filename; /* filename */ }; static asdl_seq *seq_for_testlist(struct compiling *, const node *); static expr_ty ast_for_expr(struct compiling *, const node *); static stmt_ty ast_for_stmt(struct compiling *, const node *); static asdl_seq *ast_for_suite(struct compiling *, const node *); static asdl_seq *ast_for_exprlist(struct compiling *, const node *, expr_context_ty); static expr_ty ast_for_testlist(struct compiling *, const node *); static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *); static expr_ty ast_for_testlist_comp(struct compiling *, const node *); /* Note different signature for ast_for_call */ static expr_ty ast_for_call(struct compiling *, const node *, expr_ty); static PyObject *parsenumber(struct compiling *, const char *); static PyObject *parsestr(struct compiling *, const node *n, const char *); static PyObject *parsestrplus(struct compiling *, const node *n); static int Py_Py3kWarningFlag = 0; static int Py_UnicodeFlag = 0; extern long Ta27OS_strtol(char *str, char **ptr, int base); #ifndef LINENO #define LINENO(n) ((n)->n_lineno) #endif #define COMP_GENEXP 0 #define COMP_SETCOMP 1 static identifier new_identifier(const char* n, PyArena *arena) { PyObject* id = PyUnicode_InternFromString(n); if (id != NULL) PyArena_AddPyObject(arena, id); return id; } #define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena) static string new_type_comment(const char *s, struct compiling *c) { return PyUnicode_DecodeUTF8(s, strlen(s), NULL); } #define NEW_TYPE_COMMENT(n) new_type_comment(STR(n), c) /* This routine provides an invalid object for the syntax error. The outermost routine must unpack this error and create the proper object. We do this so that we don't have to pass the filename to everything function. XXX Maybe we should just pass the filename... */ static int ast_error(const node *n, const char *errstr) { PyObject *u = Py_BuildValue("zi", errstr, LINENO(n)); if (!u) return 0; PyErr_SetObject(PyExc_SyntaxError, u); Py_DECREF(u); return 0; } static void ast_error_finish(const char *filename) { PyObject *type, *value, *tback, *errstr, *loc, *tmp; long lineno; assert(PyErr_Occurred()); if (!PyErr_ExceptionMatches(PyExc_SyntaxError)) return; PyErr_Fetch(&type, &value, &tback); errstr = PyTuple_GetItem(value, 0); if (!errstr) return; Py_INCREF(errstr); lineno = PyLong_AsLong(PyTuple_GetItem(value, 1)); if (lineno == -1) { Py_DECREF(errstr); return; } Py_DECREF(value); loc = PyErr_ProgramText(filename, lineno); if (!loc) { Py_INCREF(Py_None); loc = Py_None; } tmp = Py_BuildValue("(zlOO)", filename, lineno, Py_None, loc); Py_DECREF(loc); if (!tmp) { Py_DECREF(errstr); return; } value = PyTuple_Pack(2, errstr, tmp); Py_DECREF(errstr); Py_DECREF(tmp); if (!value) return; PyErr_Restore(type, value, tback); } static int ast_warn(struct compiling *c, const node *n, char *msg) { if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, LINENO(n), NULL, NULL) < 0) { /* if -Werr, change it to a SyntaxError */ if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning)) ast_error(n, msg); return 0; } return 1; } static int forbidden_check(struct compiling *c, const node *n, const char *x) { if (!strcmp(x, "None")) return ast_error(n, "cannot assign to None"); if (!strcmp(x, "__debug__")) return ast_error(n, "cannot assign to __debug__"); if (Py_Py3kWarningFlag) { if (!(strcmp(x, "True") && strcmp(x, "False")) && !ast_warn(c, n, "assignment to True or False is forbidden in 3.x")) return 0; if (!strcmp(x, "nonlocal") && !ast_warn(c, n, "nonlocal is a keyword in 3.x")) return 0; } return 1; } /* num_stmts() returns number of contained statements. Use this routine to determine how big a sequence is needed for the statements in a parse tree. Its raison d'etre is this bit of grammar: stmt: simple_stmt | compound_stmt simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE A simple_stmt can contain multiple small_stmt elements joined by semicolons. If the arg is a simple_stmt, the number of small_stmt elements is returned. */ static int num_stmts(const node *n) { int i, l; node *ch; switch (TYPE(n)) { case single_input: if (TYPE(CHILD(n, 0)) == NEWLINE) return 0; else return num_stmts(CHILD(n, 0)); case file_input: l = 0; for (i = 0; i < NCH(n); i++) { ch = CHILD(n, i); if (TYPE(ch) == stmt) l += num_stmts(ch); } return l; case stmt: return num_stmts(CHILD(n, 0)); case compound_stmt: return 1; case simple_stmt: return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */ case suite: /* suite: simple_stmt | NEWLINE [TYPE_COMMENT NEWLINE] INDENT stmt+ DEDENT */ if (NCH(n) == 1) return num_stmts(CHILD(n, 0)); else { i = 2; l = 0; if (TYPE(CHILD(n, 1)) == TYPE_COMMENT) i += 2; for (; i < (NCH(n) - 1); i++) l += num_stmts(CHILD(n, i)); return l; } default: { char buf[128]; sprintf(buf, "Non-statement found: %d %d", TYPE(n), NCH(n)); Py_FatalError(buf); } } assert(0); return 0; } /* Transform the CST rooted at node * to the appropriate AST */ mod_ty Ta27AST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename, PyArena *arena) { int i, j, k, num; asdl_seq *stmts = NULL; asdl_seq *type_ignores = NULL; stmt_ty s; node *ch; struct compiling c; asdl_seq *argtypes = NULL; expr_ty ret, arg; if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) { c.c_encoding = "utf-8"; if (TYPE(n) == encoding_decl) { ast_error(n, "encoding declaration in Unicode string"); goto error; } } else if (TYPE(n) == encoding_decl) { c.c_encoding = STR(n); n = CHILD(n, 0); } else { c.c_encoding = NULL; } c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS; c.c_arena = arena; c.c_filename = filename; k = 0; switch (TYPE(n)) { case file_input: stmts = asdl_seq_new(num_stmts(n), arena); if (!stmts) return NULL; for (i = 0; i < NCH(n) - 1; i++) { ch = CHILD(n, i); if (TYPE(ch) == NEWLINE) continue; REQ(ch, stmt); num = num_stmts(ch); if (num == 1) { s = ast_for_stmt(&c, ch); if (!s) goto error; asdl_seq_SET(stmts, k++, s); } else { ch = CHILD(ch, 0); REQ(ch, simple_stmt); for (j = 0; j < num; j++) { s = ast_for_stmt(&c, CHILD(ch, j * 2)); if (!s) goto error; asdl_seq_SET(stmts, k++, s); } } } /* Type ignores are stored under the ENDMARKER in file_input. */ ch = CHILD(n, NCH(n) - 1); REQ(ch, ENDMARKER); num = NCH(ch); type_ignores = _Py_asdl_seq_new(num, arena); if (!type_ignores) goto error; for (i = 0; i < num; i++) { type_ignore_ty ti = TypeIgnore(LINENO(CHILD(ch, i)), arena); if (!ti) goto error; asdl_seq_SET(type_ignores, i, ti); } return Module(stmts, type_ignores, arena); case eval_input: { expr_ty testlist_ast; /* XXX Why not comp_for here? */ testlist_ast = ast_for_testlist(&c, CHILD(n, 0)); if (!testlist_ast) goto error; return Expression(testlist_ast, arena); } case single_input: if (TYPE(CHILD(n, 0)) == NEWLINE) { stmts = asdl_seq_new(1, arena); if (!stmts) goto error; asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset, arena)); if (!asdl_seq_GET(stmts, 0)) goto error; return Interactive(stmts, arena); } else { n = CHILD(n, 0); num = num_stmts(n); stmts = asdl_seq_new(num, arena); if (!stmts) goto error; if (num == 1) { s = ast_for_stmt(&c, n); if (!s) goto error; asdl_seq_SET(stmts, 0, s); } else { /* Only a simple_stmt can contain multiple statements. */ REQ(n, simple_stmt); for (i = 0; i < NCH(n); i += 2) { if (TYPE(CHILD(n, i)) == NEWLINE) break; s = ast_for_stmt(&c, CHILD(n, i)); if (!s) goto error; asdl_seq_SET(stmts, i / 2, s); } } return Interactive(stmts, arena); } case func_type_input: n = CHILD(n, 0); REQ(n, func_type); if (TYPE(CHILD(n, 1)) == typelist) { ch = CHILD(n, 1); /* this is overly permissive -- we don't pay any attention to * stars on the args -- just parse them into an ordered list */ num = 0; for (i = 0; i < NCH(ch); i++) { if (TYPE(CHILD(ch, i)) == test) num++; } argtypes = _Py_asdl_seq_new(num, arena); j = 0; for (i = 0; i < NCH(ch); i++) { if (TYPE(CHILD(ch, i)) == test) { arg = ast_for_expr(&c, CHILD(ch, i)); if (!arg) goto error; asdl_seq_SET(argtypes, j++, arg); } } } else argtypes = _Py_asdl_seq_new(0, arena); ret = ast_for_expr(&c, CHILD(n, NCH(n) - 1)); if (!ret) goto error; return FunctionType(argtypes, ret, arena); default: PyErr_Format(PyExc_SystemError, "invalid node %d for Ta27AST_FromNode", TYPE(n)); goto error; } error: ast_error_finish(filename); return NULL; } /* Return the AST repr. of the operator represented as syntax (|, ^, etc.) */ static operator_ty get_operator(const node *n) { switch (TYPE(n)) { case VBAR: return BitOr; case CIRCUMFLEX: return BitXor; case AMPER: return BitAnd; case LEFTSHIFT: return LShift; case RIGHTSHIFT: return RShift; case PLUS: return Add; case MINUS: return Sub; case STAR: return Mult; case SLASH: return Div; case DOUBLESLASH: return FloorDiv; case PERCENT: return Mod; default: return (operator_ty)0; } } /* Set the context ctx for expr_ty e, recursively traversing e. Only sets context for expr kinds that "can appear in assignment context" (according to ../Parser/Python.asdl). For other expr kinds, it sets an appropriate syntax error and returns false. */ static int set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n) { asdl_seq *s = NULL; /* If a particular expression type can't be used for assign / delete, set expr_name to its name and an error message will be generated. */ const char* expr_name = NULL; /* The ast defines augmented store and load contexts, but the implementation here doesn't actually use them. The code may be a little more complex than necessary as a result. It also means that expressions in an augmented assignment have a Store context. Consider restructuring so that augmented assignment uses set_context(), too. */ assert(ctx != AugStore && ctx != AugLoad); switch (e->kind) { case Attribute_kind: if (ctx == Store && !forbidden_check(c, n, PyUnicode_AsUTF8(e->v.Attribute.attr))) return 0; e->v.Attribute.ctx = ctx; break; case Subscript_kind: e->v.Subscript.ctx = ctx; break; case Name_kind: if (ctx == Store && !forbidden_check(c, n, PyUnicode_AsUTF8(e->v.Name.id))) return 0; e->v.Name.ctx = ctx; break; case List_kind: e->v.List.ctx = ctx; s = e->v.List.elts; break; case Tuple_kind: if (asdl_seq_LEN(e->v.Tuple.elts)) { e->v.Tuple.ctx = ctx; s = e->v.Tuple.elts; } else { expr_name = "()"; } break; case Lambda_kind: expr_name = "lambda"; break; case Call_kind: expr_name = "function call"; break; case BoolOp_kind: case BinOp_kind: case UnaryOp_kind: expr_name = "operator"; break; case GeneratorExp_kind: expr_name = "generator expression"; break; case Yield_kind: expr_name = "yield expression"; break; case ListComp_kind: expr_name = "list comprehension"; break; case SetComp_kind: expr_name = "set comprehension"; break; case DictComp_kind: expr_name = "dict comprehension"; break; case Dict_kind: case Set_kind: case Num_kind: case Str_kind: expr_name = "literal"; break; case Compare_kind: expr_name = "comparison"; break; case Repr_kind: expr_name = "repr"; break; case IfExp_kind: expr_name = "conditional expression"; break; default: PyErr_Format(PyExc_SystemError, "unexpected expression in assignment %d (line %d)", e->kind, e->lineno); return 0; } /* Check for error string set by switch */ if (expr_name) { char buf[300]; PyOS_snprintf(buf, sizeof(buf), "can't %s %s", ctx == Store ? "assign to" : "delete", expr_name); return ast_error(n, buf); } /* If the LHS is a list or tuple, we need to set the assignment context for all the contained elements. */ if (s) { int i; for (i = 0; i < asdl_seq_LEN(s); i++) { if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n)) return 0; } } return 1; } static operator_ty ast_for_augassign(struct compiling *c, const node *n) { REQ(n, augassign); n = CHILD(n, 0); switch (STR(n)[0]) { case '+': return Add; case '-': return Sub; case '/': if (STR(n)[1] == '/') return FloorDiv; else return Div; case '%': return Mod; case '<': return LShift; case '>': return RShift; case '&': return BitAnd; case '^': return BitXor; case '|': return BitOr; case '*': if (STR(n)[1] == '*') return Pow; else return Mult; default: PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n)); return (operator_ty)0; } } static cmpop_ty ast_for_comp_op(struct compiling *c, const node *n) { /* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is' |'is' 'not' */ REQ(n, comp_op); if (NCH(n) == 1) { n = CHILD(n, 0); switch (TYPE(n)) { case LESS: return Lt; case GREATER: return Gt; case EQEQUAL: /* == */ return Eq; case LESSEQUAL: return LtE; case GREATEREQUAL: return GtE; case NOTEQUAL: return NotEq; case NAME: if (strcmp(STR(n), "in") == 0) return In; if (strcmp(STR(n), "is") == 0) return Is; default: PyErr_Format(PyExc_SystemError, "invalid comp_op: %s", STR(n)); return (cmpop_ty)0; } } else if (NCH(n) == 2) { /* handle "not in" and "is not" */ switch (TYPE(CHILD(n, 0))) { case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0) return NotIn; if (strcmp(STR(CHILD(n, 0)), "is") == 0) return IsNot; default: PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s", STR(CHILD(n, 0)), STR(CHILD(n, 1))); return (cmpop_ty)0; } } PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children", NCH(n)); return (cmpop_ty)0; } static asdl_seq * seq_for_testlist(struct compiling *c, const node *n) { /* testlist: test (',' test)* [','] */ asdl_seq *seq; expr_ty expression; int i; assert(TYPE(n) == testlist || TYPE(n) == listmaker || TYPE(n) == testlist_comp || TYPE(n) == testlist_safe || TYPE(n) == testlist1); seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { assert(TYPE(CHILD(n, i)) == test || TYPE(CHILD(n, i)) == old_test); expression = ast_for_expr(c, CHILD(n, i)); if (!expression) return NULL; assert(i / 2 < seq->size); asdl_seq_SET(seq, i / 2, expression); } return seq; } static expr_ty compiler_complex_args(struct compiling *c, const node *n) { int i, len = (NCH(n) + 1) / 2; expr_ty result; asdl_seq *args = asdl_seq_new(len, c->c_arena); if (!args) return NULL; /* fpdef: NAME | '(' fplist ')' fplist: fpdef (',' fpdef)* [','] */ REQ(n, fplist); for (i = 0; i < len; i++) { PyObject *arg_id; const node *fpdef_node = CHILD(n, 2*i); const node *child; expr_ty arg; set_name: /* fpdef_node is either a NAME or an fplist */ child = CHILD(fpdef_node, 0); if (TYPE(child) == NAME) { if (!forbidden_check(c, n, STR(child))) return NULL; arg_id = NEW_IDENTIFIER(child); if (!arg_id) return NULL; arg = Name(arg_id, Store, LINENO(child), child->n_col_offset, c->c_arena); } else { assert(TYPE(fpdef_node) == fpdef); /* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */ child = CHILD(fpdef_node, 1); assert(TYPE(child) == fplist); /* NCH == 1 means we have (x), we need to elide the extra parens */ if (NCH(child) == 1) { fpdef_node = CHILD(child, 0); assert(TYPE(fpdef_node) == fpdef); goto set_name; } arg = compiler_complex_args(c, child); } asdl_seq_SET(args, i, arg); } result = Tuple(args, Store, LINENO(n), n->n_col_offset, c->c_arena); if (!set_context(c, result, Store, n)) return NULL; return result; } /* Create AST for argument list. */ static arguments_ty ast_for_arguments(struct compiling *c, const node *n) { /* parameters: '(' [varargslist] ')' varargslist: ((fpdef ['=' test] ',' [TYPE_COMMENT])* ('*' NAME [',' [TYPE_COMMENT] '**' NAME] [TYPE_COMMENT] | '**' NAME [TYPE_COMMENT]) | fpdef ['=' test] (',' [TYPE_COMMENT] fpdef ['=' test])* [','] [TYPE_COMMENT]) */ int i, j, k, l, n_args = 0, n_all_args = 0, n_defaults = 0, found_default = 0; asdl_seq *args, *defaults, *type_comments = NULL; identifier vararg = NULL, kwarg = NULL; node *ch; if (TYPE(n) == parameters) { if (NCH(n) == 2) /* () as argument list */ return arguments(NULL, NULL, NULL, NULL, NULL, c->c_arena); n = CHILD(n, 1); } REQ(n, varargslist); /* first count the number of normal args & defaults */ for (i = 0; i < NCH(n); i++) { ch = CHILD(n, i); if (TYPE(ch) == fpdef) n_args++; if (TYPE(ch) == EQUAL) n_defaults++; if (TYPE(ch) == STAR || TYPE(ch) == DOUBLESTAR) n_all_args++; } n_all_args += n_args; args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL); if (!args && n_args) return NULL; defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL); if (!defaults && n_defaults) return NULL; /* type_comments will be lazily initialized if needed. If there are no per-argument type comments, it will remain NULL. Otherwise, it will be an asdl_seq with length equal to the number of args (including varargs and kwargs, if present) and with members set to the string of each arg's type comment, if present, or NULL otherwise. */ /* fpdef: NAME | '(' fplist ')' fplist: fpdef (',' fpdef)* [','] */ i = 0; j = 0; /* index for defaults */ k = 0; /* index for args */ l = 0; /* index for type comments */ while (i < NCH(n)) { ch = CHILD(n, i); switch (TYPE(ch)) { case fpdef: { int complex_args = 0, parenthesized = 0; handle_fpdef: /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is anything other than EQUAL or a comma? */ /* XXX Should NCH(n) check be made a separate check? */ if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) { expr_ty expression = ast_for_expr(c, CHILD(n, i + 2)); if (!expression) return NULL; assert(defaults != NULL); asdl_seq_SET(defaults, j++, expression); i += 2; found_default = 1; } else if (found_default) { /* def f((x)=4): pass should raise an error. def f((x, (y))): pass will just incur the tuple unpacking warning. */ if (parenthesized && !complex_args) { ast_error(n, "parenthesized arg with default"); return NULL; } ast_error(n, "non-default argument follows default argument"); return NULL; } if (NCH(ch) == 3) { ch = CHILD(ch, 1); /* def foo((x)): is not complex, special case. */ if (NCH(ch) != 1) { /* We have complex arguments, setup for unpacking. */ if (Py_Py3kWarningFlag && !ast_warn(c, ch, "tuple parameter unpacking has been removed in 3.x")) return NULL; complex_args = 1; asdl_seq_SET(args, k++, compiler_complex_args(c, ch)); if (!asdl_seq_GET(args, k-1)) return NULL; } else { /* def foo((x)): setup for checking NAME below. */ /* Loop because there can be many parens and tuple unpacking mixed in. */ parenthesized = 1; ch = CHILD(ch, 0); assert(TYPE(ch) == fpdef); goto handle_fpdef; } } if (TYPE(CHILD(ch, 0)) == NAME) { PyObject *id; expr_ty name; if (!forbidden_check(c, n, STR(CHILD(ch, 0)))) return NULL; id = NEW_IDENTIFIER(CHILD(ch, 0)); if (!id) return NULL; name = Name(id, Param, LINENO(ch), ch->n_col_offset, c->c_arena); if (!name) return NULL; asdl_seq_SET(args, k++, name); } i += 1; /* the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ if (parenthesized && Py_Py3kWarningFlag && !ast_warn(c, ch, "parenthesized argument names " "are invalid in 3.x")) return NULL; break; } case STAR: if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1)))) return NULL; vararg = NEW_IDENTIFIER(CHILD(n, i+1)); if (!vararg) return NULL; i += 2; /* the star and the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ break; case DOUBLESTAR: if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1)))) return NULL; kwarg = NEW_IDENTIFIER(CHILD(n, i+1)); if (!kwarg) return NULL; i += 2; /* the double star and the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ break; case TYPE_COMMENT: assert(l < k + !!vararg + !!kwarg); if (!type_comments) { /* lazily allocate the type_comments seq for perf reasons */ type_comments = asdl_seq_new(n_all_args, c->c_arena); if (!type_comments) return NULL; } while (l < k + !!vararg + !!kwarg - 1) { asdl_seq_SET(type_comments, l++, NULL); } asdl_seq_SET(type_comments, l++, NEW_TYPE_COMMENT(ch)); i += 1; break; default: PyErr_Format(PyExc_SystemError, "unexpected node in varargslist: %d @ %d", TYPE(ch), i); return NULL; } } if (type_comments) { while (l < n_all_args) { asdl_seq_SET(type_comments, l++, NULL); } } return arguments(args, vararg, kwarg, defaults, type_comments, c->c_arena); } static expr_ty ast_for_dotted_name(struct compiling *c, const node *n) { expr_ty e; identifier id; int lineno, col_offset; int i; REQ(n, dotted_name); lineno = LINENO(n); col_offset = n->n_col_offset; id = NEW_IDENTIFIER(CHILD(n, 0)); if (!id) return NULL; e = Name(id, Load, lineno, col_offset, c->c_arena); if (!e) return NULL; for (i = 2; i < NCH(n); i+=2) { id = NEW_IDENTIFIER(CHILD(n, i)); if (!id) return NULL; e = Attribute(e, id, Load, lineno, col_offset, c->c_arena); if (!e) return NULL; } return e; } static expr_ty ast_for_decorator(struct compiling *c, const node *n) { /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */ expr_ty d = NULL; expr_ty name_expr; REQ(n, decorator); REQ(CHILD(n, 0), AT); REQ(RCHILD(n, -1), NEWLINE); name_expr = ast_for_dotted_name(c, CHILD(n, 1)); if (!name_expr) return NULL; if (NCH(n) == 3) { /* No arguments */ d = name_expr; name_expr = NULL; } else if (NCH(n) == 5) { /* Call with no arguments */ d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); if (!d) return NULL; name_expr = NULL; } else { d = ast_for_call(c, CHILD(n, 3), name_expr); if (!d) return NULL; name_expr = NULL; } return d; } static asdl_seq* ast_for_decorators(struct compiling *c, const node *n) { asdl_seq* decorator_seq; expr_ty d; int i; REQ(n, decorators); decorator_seq = asdl_seq_new(NCH(n), c->c_arena); if (!decorator_seq) return NULL; for (i = 0; i < NCH(n); i++) { d = ast_for_decorator(c, CHILD(n, i)); if (!d) return NULL; asdl_seq_SET(decorator_seq, i, d); } return decorator_seq; } static stmt_ty ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) { /* funcdef: 'def' NAME parameters ':' [TYPE_COMMENT] suite */ identifier name; arguments_ty args; asdl_seq *body; int name_i = 1; node *tc; string type_comment = NULL; REQ(n, funcdef); name = NEW_IDENTIFIER(CHILD(n, name_i)); if (!name) return NULL; else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i)))) return NULL; args = ast_for_arguments(c, CHILD(n, name_i + 1)); if (!args) return NULL; if (TYPE(CHILD(n, name_i + 3)) == TYPE_COMMENT) { type_comment = NEW_TYPE_COMMENT(CHILD(n, name_i + 3)); name_i += 1; } body = ast_for_suite(c, CHILD(n, name_i + 3)); if (!body) return NULL; if (!type_comment && NCH(CHILD(n, name_i + 3)) > 1) { /* If the function doesn't have a type comment on the same line, check * if the suite has a type comment in it. */ tc = CHILD(CHILD(n, name_i + 3), 1); if (TYPE(tc) == TYPE_COMMENT) type_comment = NEW_TYPE_COMMENT(tc); } return FunctionDef(name, args, body, decorator_seq, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_decorated(struct compiling *c, const node *n) { /* decorated: decorators (classdef | funcdef) */ stmt_ty thing = NULL; asdl_seq *decorator_seq = NULL; REQ(n, decorated); decorator_seq = ast_for_decorators(c, CHILD(n, 0)); if (!decorator_seq) return NULL; assert(TYPE(CHILD(n, 1)) == funcdef || TYPE(CHILD(n, 1)) == classdef); if (TYPE(CHILD(n, 1)) == funcdef) { thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq); } else if (TYPE(CHILD(n, 1)) == classdef) { thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq); } /* we count the decorators in when talking about the class' or function's line number */ if (thing) { thing->lineno = LINENO(n); thing->col_offset = n->n_col_offset; } return thing; } static expr_ty ast_for_lambdef(struct compiling *c, const node *n) { /* lambdef: 'lambda' [varargslist] ':' test */ arguments_ty args; expr_ty expression; if (NCH(n) == 3) { args = arguments(NULL, NULL, NULL, NULL, NULL, c->c_arena); if (!args) return NULL; expression = ast_for_expr(c, CHILD(n, 2)); if (!expression) return NULL; } else { args = ast_for_arguments(c, CHILD(n, 1)); if (!args) return NULL; expression = ast_for_expr(c, CHILD(n, 3)); if (!expression) return NULL; } return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_ifexpr(struct compiling *c, const node *n) { /* test: or_test 'if' or_test 'else' test */ expr_ty expression, body, orelse; assert(NCH(n) == 5); body = ast_for_expr(c, CHILD(n, 0)); if (!body) return NULL; expression = ast_for_expr(c, CHILD(n, 2)); if (!expression) return NULL; orelse = ast_for_expr(c, CHILD(n, 4)); if (!orelse) return NULL; return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset, c->c_arena); } /* XXX(nnorwitz): the listcomp and genexpr code should be refactored so there is only a single version. Possibly for loops can also re-use the code. */ /* Count the number of 'for' loop in a list comprehension. Helper for ast_for_listcomp(). */ static int count_list_fors(struct compiling *c, const node *n) { int n_fors = 0; node *ch = CHILD(n, 1); count_list_for: n_fors++; REQ(ch, list_for); if (NCH(ch) == 5) ch = CHILD(ch, 4); else return n_fors; count_list_iter: REQ(ch, list_iter); ch = CHILD(ch, 0); if (TYPE(ch) == list_for) goto count_list_for; else if (TYPE(ch) == list_if) { if (NCH(ch) == 3) { ch = CHILD(ch, 2); goto count_list_iter; } else return n_fors; } /* Should never be reached */ PyErr_SetString(PyExc_SystemError, "logic error in count_list_fors"); return -1; } /* Count the number of 'if' statements in a list comprehension. Helper for ast_for_listcomp(). */ static int count_list_ifs(struct compiling *c, const node *n) { int n_ifs = 0; count_list_iter: REQ(n, list_iter); if (TYPE(CHILD(n, 0)) == list_for) return n_ifs; n = CHILD(n, 0); REQ(n, list_if); n_ifs++; if (NCH(n) == 2) return n_ifs; n = CHILD(n, 2); goto count_list_iter; } static expr_ty ast_for_listcomp(struct compiling *c, const node *n) { /* listmaker: test ( list_for | (',' test)* [','] ) list_for: 'for' exprlist 'in' testlist_safe [list_iter] list_iter: list_for | list_if list_if: 'if' test [list_iter] testlist_safe: test [(',' test)+ [',']] */ expr_ty elt, first; asdl_seq *listcomps; int i, n_fors; node *ch; REQ(n, listmaker); assert(NCH(n) > 1); elt = ast_for_expr(c, CHILD(n, 0)); if (!elt) return NULL; n_fors = count_list_fors(c, n); if (n_fors == -1) return NULL; listcomps = asdl_seq_new(n_fors, c->c_arena); if (!listcomps) return NULL; ch = CHILD(n, 1); for (i = 0; i < n_fors; i++) { comprehension_ty lc; asdl_seq *t; expr_ty expression; node *for_ch; REQ(ch, list_for); for_ch = CHILD(ch, 1); t = ast_for_exprlist(c, for_ch, Store); if (!t) return NULL; expression = ast_for_testlist(c, CHILD(ch, 3)); if (!expression) return NULL; /* Check the # of children rather than the length of t, since [x for x, in ... ] has 1 element in t, but still requires a Tuple. */ first = (expr_ty)asdl_seq_GET(t, 0); if (NCH(for_ch) == 1) lc = comprehension(first, expression, NULL, c->c_arena); else lc = comprehension(Tuple(t, Store, first->lineno, first->col_offset, c->c_arena), expression, NULL, c->c_arena); if (!lc) return NULL; if (NCH(ch) == 5) { int j, n_ifs; asdl_seq *ifs; expr_ty list_for_expr; ch = CHILD(ch, 4); n_ifs = count_list_ifs(c, ch); if (n_ifs == -1) return NULL; ifs = asdl_seq_new(n_ifs, c->c_arena); if (!ifs) return NULL; for (j = 0; j < n_ifs; j++) { REQ(ch, list_iter); ch = CHILD(ch, 0); REQ(ch, list_if); list_for_expr = ast_for_expr(c, CHILD(ch, 1)); if (!list_for_expr) return NULL; asdl_seq_SET(ifs, j, list_for_expr); if (NCH(ch) == 3) ch = CHILD(ch, 2); } /* on exit, must guarantee that ch is a list_for */ if (TYPE(ch) == list_iter) ch = CHILD(ch, 0); lc->ifs = ifs; } asdl_seq_SET(listcomps, i, lc); } return ListComp(elt, listcomps, LINENO(n), n->n_col_offset, c->c_arena); } /* Count the number of 'for' loops in a comprehension. Helper for ast_for_comprehension(). */ static int count_comp_fors(struct compiling *c, const node *n) { int n_fors = 0; count_comp_for: n_fors++; REQ(n, comp_for); if (NCH(n) == 5) n = CHILD(n, 4); else return n_fors; count_comp_iter: REQ(n, comp_iter); n = CHILD(n, 0); if (TYPE(n) == comp_for) goto count_comp_for; else if (TYPE(n) == comp_if) { if (NCH(n) == 3) { n = CHILD(n, 2); goto count_comp_iter; } else return n_fors; } /* Should never be reached */ PyErr_SetString(PyExc_SystemError, "logic error in count_comp_fors"); return -1; } /* Count the number of 'if' statements in a comprehension. Helper for ast_for_comprehension(). */ static int count_comp_ifs(struct compiling *c, const node *n) { int n_ifs = 0; while (1) { REQ(n, comp_iter); if (TYPE(CHILD(n, 0)) == comp_for) return n_ifs; n = CHILD(n, 0); REQ(n, comp_if); n_ifs++; if (NCH(n) == 2) return n_ifs; n = CHILD(n, 2); } } static asdl_seq * ast_for_comprehension(struct compiling *c, const node *n) { int i, n_fors; asdl_seq *comps; n_fors = count_comp_fors(c, n); if (n_fors == -1) return NULL; comps = asdl_seq_new(n_fors, c->c_arena); if (!comps) return NULL; for (i = 0; i < n_fors; i++) { comprehension_ty comp; asdl_seq *t; expr_ty expression, first; node *for_ch; REQ(n, comp_for); for_ch = CHILD(n, 1); t = ast_for_exprlist(c, for_ch, Store); if (!t) return NULL; expression = ast_for_expr(c, CHILD(n, 3)); if (!expression) return NULL; /* Check the # of children rather than the length of t, since (x for x, in ...) has 1 element in t, but still requires a Tuple. */ first = (expr_ty)asdl_seq_GET(t, 0); if (NCH(for_ch) == 1) comp = comprehension(first, expression, NULL, c->c_arena); else comp = comprehension(Tuple(t, Store, first->lineno, first->col_offset, c->c_arena), expression, NULL, c->c_arena); if (!comp) return NULL; if (NCH(n) == 5) { int j, n_ifs; asdl_seq *ifs; n = CHILD(n, 4); n_ifs = count_comp_ifs(c, n); if (n_ifs == -1) return NULL; ifs = asdl_seq_new(n_ifs, c->c_arena); if (!ifs) return NULL; for (j = 0; j < n_ifs; j++) { REQ(n, comp_iter); n = CHILD(n, 0); REQ(n, comp_if); expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; asdl_seq_SET(ifs, j, expression); if (NCH(n) == 3) n = CHILD(n, 2); } /* on exit, must guarantee that n is a comp_for */ if (TYPE(n) == comp_iter) n = CHILD(n, 0); comp->ifs = ifs; } asdl_seq_SET(comps, i, comp); } return comps; } static expr_ty ast_for_itercomp(struct compiling *c, const node *n, int type) { expr_ty elt; asdl_seq *comps; assert(NCH(n) > 1); elt = ast_for_expr(c, CHILD(n, 0)); if (!elt) return NULL; comps = ast_for_comprehension(c, CHILD(n, 1)); if (!comps) return NULL; if (type == COMP_GENEXP) return GeneratorExp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena); else if (type == COMP_SETCOMP) return SetComp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena); else /* Should never happen */ return NULL; } static expr_ty ast_for_dictcomp(struct compiling *c, const node *n) { expr_ty key, value; asdl_seq *comps; assert(NCH(n) > 3); REQ(CHILD(n, 1), COLON); key = ast_for_expr(c, CHILD(n, 0)); if (!key) return NULL; value = ast_for_expr(c, CHILD(n, 2)); if (!value) return NULL; comps = ast_for_comprehension(c, CHILD(n, 3)); if (!comps) return NULL; return DictComp(key, value, comps, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_genexp(struct compiling *c, const node *n) { assert(TYPE(n) == (testlist_comp) || TYPE(n) == (argument)); return ast_for_itercomp(c, n, COMP_GENEXP); } static expr_ty ast_for_setcomp(struct compiling *c, const node *n) { assert(TYPE(n) == (dictorsetmaker)); return ast_for_itercomp(c, n, COMP_SETCOMP); } static expr_ty ast_for_atom(struct compiling *c, const node *n) { /* atom: '(' [yield_expr|testlist_comp] ')' | '[' [listmaker] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+ */ node *ch = CHILD(n, 0); switch (TYPE(ch)) { case NAME: { /* All names start in Load context, but may later be changed. */ PyObject *name = NEW_IDENTIFIER(ch); if (!name) return NULL; return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena); } case STRING: { PyObject *str = parsestrplus(c, n); const char *s = STR(CHILD(n, 0)); int quote = Py_CHARMASK(*s); int has_b = 0; if (!str) { #ifdef Py_USING_UNICODE if (PyErr_ExceptionMatches(PyExc_UnicodeError)){ PyObject *type, *value, *tback, *errstr; PyErr_Fetch(&type, &value, &tback); errstr = PyObject_Str(value); if (errstr) { char *s = ""; char buf[128]; s = _PyUnicode_AsString(errstr); PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s); ast_error(n, buf); Py_DECREF(errstr); } else { ast_error(n, "(unicode error) unknown error"); } Py_DECREF(type); Py_DECREF(value); Py_XDECREF(tback); } #endif return NULL; } PyArena_AddPyObject(c->c_arena, str); if (quote == 'b' || quote == 'B') { has_b = 1; } return Str(str, has_b, LINENO(n), n->n_col_offset, c->c_arena); } case NUMBER: { PyObject *pynum = parsenumber(c, STR(ch)); if (!pynum) return NULL; PyArena_AddPyObject(c->c_arena, pynum); return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena); } case LPAR: /* some parenthesized expressions */ ch = CHILD(n, 1); if (TYPE(ch) == RPAR) return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena); if (TYPE(ch) == yield_expr) return ast_for_expr(c, ch); return ast_for_testlist_comp(c, ch); case LSQB: /* list (or list comprehension) */ ch = CHILD(n, 1); if (TYPE(ch) == RSQB) return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena); REQ(ch, listmaker); if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) { asdl_seq *elts = seq_for_testlist(c, ch); if (!elts) return NULL; return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena); } else return ast_for_listcomp(c, ch); case LBRACE: { /* dictorsetmaker: * (test ':' test (comp_for | (',' test ':' test)* [','])) | * (test (comp_for | (',' test)* [','])) */ int i, size; asdl_seq *keys, *values; ch = CHILD(n, 1); if (TYPE(ch) == RBRACE) { /* it's an empty dict */ return Dict(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) { /* it's a simple set */ asdl_seq *elts; size = (NCH(ch) + 1) / 2; /* +1 in case no trailing comma */ elts = asdl_seq_new(size, c->c_arena); if (!elts) return NULL; for (i = 0; i < NCH(ch); i += 2) { expr_ty expression; expression = ast_for_expr(c, CHILD(ch, i)); if (!expression) return NULL; asdl_seq_SET(elts, i / 2, expression); } return Set(elts, LINENO(n), n->n_col_offset, c->c_arena); } else if (TYPE(CHILD(ch, 1)) == comp_for) { /* it's a set comprehension */ return ast_for_setcomp(c, ch); } else if (NCH(ch) > 3 && TYPE(CHILD(ch, 3)) == comp_for) { return ast_for_dictcomp(c, ch); } else { /* it's a dict */ size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */ keys = asdl_seq_new(size, c->c_arena); if (!keys) return NULL; values = asdl_seq_new(size, c->c_arena); if (!values) return NULL; for (i = 0; i < NCH(ch); i += 4) { expr_ty expression; expression = ast_for_expr(c, CHILD(ch, i)); if (!expression) return NULL; asdl_seq_SET(keys, i / 4, expression); expression = ast_for_expr(c, CHILD(ch, i + 2)); if (!expression) return NULL; asdl_seq_SET(values, i / 4, expression); } return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena); } } case BACKQUOTE: { /* repr */ expr_ty expression; if (Py_Py3kWarningFlag && !ast_warn(c, n, "backquote not supported in 3.x; use repr()")) return NULL; expression = ast_for_testlist(c, CHILD(n, 1)); if (!expression) return NULL; return Repr(expression, LINENO(n), n->n_col_offset, c->c_arena); } default: PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch)); return NULL; } } static slice_ty ast_for_slice(struct compiling *c, const node *n) { node *ch; expr_ty lower = NULL, upper = NULL, step = NULL; REQ(n, subscript); /* subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] sliceop: ':' [test] */ ch = CHILD(n, 0); if (TYPE(ch) == DOT) return Ellipsis(c->c_arena); if (NCH(n) == 1 && TYPE(ch) == test) { /* 'step' variable hold no significance in terms of being used over other vars */ step = ast_for_expr(c, ch); if (!step) return NULL; return Index(step, c->c_arena); } if (TYPE(ch) == test) { lower = ast_for_expr(c, ch); if (!lower) return NULL; } /* If there's an upper bound it's in the second or third position. */ if (TYPE(ch) == COLON) { if (NCH(n) > 1) { node *n2 = CHILD(n, 1); if (TYPE(n2) == test) { upper = ast_for_expr(c, n2); if (!upper) return NULL; } } } else if (NCH(n) > 2) { node *n2 = CHILD(n, 2); if (TYPE(n2) == test) { upper = ast_for_expr(c, n2); if (!upper) return NULL; } } ch = CHILD(n, NCH(n) - 1); if (TYPE(ch) == sliceop) { if (NCH(ch) == 1) { /* This is an extended slice (ie "x[::]") with no expression in the step field. We set this literally to "None" in order to disambiguate it from x[:]. (The interpreter might have to call __getslice__ for x[:], but it must call __getitem__ for x[::].) */ identifier none = new_identifier("None", c->c_arena); if (!none) return NULL; ch = CHILD(ch, 0); step = Name(none, Load, LINENO(ch), ch->n_col_offset, c->c_arena); if (!step) return NULL; } else { ch = CHILD(ch, 1); if (TYPE(ch) == test) { step = ast_for_expr(c, ch); if (!step) return NULL; } } } return Slice(lower, upper, step, c->c_arena); } static expr_ty ast_for_binop(struct compiling *c, const node *n) { /* Must account for a sequence of expressions. How should A op B op C by represented? BinOp(BinOp(A, op, B), op, C). */ int i, nops; expr_ty expr1, expr2, result; operator_ty newoperator; expr1 = ast_for_expr(c, CHILD(n, 0)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(n, 2)); if (!expr2) return NULL; newoperator = get_operator(CHILD(n, 1)); if (!newoperator) return NULL; result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset, c->c_arena); if (!result) return NULL; nops = (NCH(n) - 1) / 2; for (i = 1; i < nops; i++) { expr_ty tmp_result, tmp; const node* next_oper = CHILD(n, i * 2 + 1); newoperator = get_operator(next_oper); if (!newoperator) return NULL; tmp = ast_for_expr(c, CHILD(n, i * 2 + 2)); if (!tmp) return NULL; tmp_result = BinOp(result, newoperator, tmp, LINENO(next_oper), next_oper->n_col_offset, c->c_arena); if (!tmp_result) return NULL; result = tmp_result; } return result; } static expr_ty ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr) { /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME subscriptlist: subscript (',' subscript)* [','] subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] */ REQ(n, trailer); if (TYPE(CHILD(n, 0)) == LPAR) { if (NCH(n) == 2) return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); else return ast_for_call(c, CHILD(n, 1), left_expr); } else if (TYPE(CHILD(n, 0)) == DOT ) { PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1)); if (!attr_id) return NULL; return Attribute(left_expr, attr_id, Load, LINENO(n), n->n_col_offset, c->c_arena); } else { REQ(CHILD(n, 0), LSQB); REQ(CHILD(n, 2), RSQB); n = CHILD(n, 1); if (NCH(n) == 1) { slice_ty slc = ast_for_slice(c, CHILD(n, 0)); if (!slc) return NULL; return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset, c->c_arena); } else { /* The grammar is ambiguous here. The ambiguity is resolved by treating the sequence as a tuple literal if there are no slice features. */ int j; slice_ty slc; expr_ty e; bool simple = true; asdl_seq *slices, *elts; slices = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!slices) return NULL; for (j = 0; j < NCH(n); j += 2) { slc = ast_for_slice(c, CHILD(n, j)); if (!slc) return NULL; if (slc->kind != Index_kind) simple = false; asdl_seq_SET(slices, j / 2, slc); } if (!simple) { return Subscript(left_expr, ExtSlice(slices, c->c_arena), Load, LINENO(n), n->n_col_offset, c->c_arena); } /* extract Index values and put them in a Tuple */ elts = asdl_seq_new(asdl_seq_LEN(slices), c->c_arena); if (!elts) return NULL; for (j = 0; j < asdl_seq_LEN(slices); ++j) { slc = (slice_ty)asdl_seq_GET(slices, j); assert(slc->kind == Index_kind && slc->v.Index.value); asdl_seq_SET(elts, j, slc->v.Index.value); } e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena); if (!e) return NULL; return Subscript(left_expr, Index(e, c->c_arena), Load, LINENO(n), n->n_col_offset, c->c_arena); } } } static expr_ty ast_for_factor(struct compiling *c, const node *n) { node *pfactor, *ppower, *patom, *pnum; expr_ty expression; /* If the unary - operator is applied to a constant, don't generate a UNARY_NEGATIVE opcode. Just store the approriate value as a constant. The peephole optimizer already does something like this but it doesn't handle the case where the constant is (sys.maxint - 1). In that case, we want a PyIntObject, not a PyLongObject. */ if (TYPE(CHILD(n, 0)) == MINUS && NCH(n) == 2 && TYPE((pfactor = CHILD(n, 1))) == factor && NCH(pfactor) == 1 && TYPE((ppower = CHILD(pfactor, 0))) == power && NCH(ppower) == 1 && TYPE((patom = CHILD(ppower, 0))) == atom && TYPE((pnum = CHILD(patom, 0))) == NUMBER) { PyObject *pynum; char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2); if (s == NULL) return NULL; s[0] = '-'; strcpy(s + 1, STR(pnum)); pynum = parsenumber(c, s); PyObject_FREE(s); if (!pynum) return NULL; PyArena_AddPyObject(c->c_arena, pynum); return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena); } expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; switch (TYPE(CHILD(n, 0))) { case PLUS: return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset, c->c_arena); case MINUS: return UnaryOp(USub, expression, LINENO(n), n->n_col_offset, c->c_arena); case TILDE: return UnaryOp(Invert, expression, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unhandled factor: %d", TYPE(CHILD(n, 0))); return NULL; } static expr_ty ast_for_power(struct compiling *c, const node *n) { /* power: atom trailer* ('**' factor)* */ int i; expr_ty e, tmp; REQ(n, power); e = ast_for_atom(c, CHILD(n, 0)); if (!e) return NULL; if (NCH(n) == 1) return e; for (i = 1; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) != trailer) break; tmp = ast_for_trailer(c, ch, e); if (!tmp) return NULL; tmp->lineno = e->lineno; tmp->col_offset = e->col_offset; e = tmp; } if (TYPE(CHILD(n, NCH(n) - 1)) == factor) { expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1)); if (!f) return NULL; tmp = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena); if (!tmp) return NULL; e = tmp; } return e; } /* Do not name a variable 'expr'! Will cause a compile error. */ static expr_ty ast_for_expr(struct compiling *c, const node *n) { /* handle the full range of simple expressions test: or_test ['if' or_test 'else' test] | lambdef or_test: and_test ('or' and_test)* and_test: not_test ('and' not_test)* not_test: 'not' not_test | comparison comparison: expr (comp_op expr)* expr: xor_expr ('|' xor_expr)* xor_expr: and_expr ('^' and_expr)* and_expr: shift_expr ('&' shift_expr)* shift_expr: arith_expr (('<<'|'>>') arith_expr)* arith_expr: term (('+'|'-') term)* term: factor (('*'|'/'|'%'|'//') factor)* factor: ('+'|'-'|'~') factor | power power: atom trailer* ('**' factor)* As well as modified versions that exist for backward compatibility, to explicitly allow: [ x for x in lambda: 0, lambda: 1 ] (which would be ambiguous without these extra rules) old_test: or_test | old_lambdef old_lambdef: 'lambda' [vararglist] ':' old_test */ asdl_seq *seq; int i; loop: switch (TYPE(n)) { case test: case old_test: if (TYPE(CHILD(n, 0)) == lambdef || TYPE(CHILD(n, 0)) == old_lambdef) return ast_for_lambdef(c, CHILD(n, 0)); else if (NCH(n) > 1) return ast_for_ifexpr(c, n); /* Fallthrough */ case or_test: case and_test: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { expr_ty e = ast_for_expr(c, CHILD(n, i)); if (!e) return NULL; asdl_seq_SET(seq, i / 2, e); } if (!strcmp(STR(CHILD(n, 1)), "and")) return BoolOp(And, seq, LINENO(n), n->n_col_offset, c->c_arena); assert(!strcmp(STR(CHILD(n, 1)), "or")); return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena); case not_test: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { expr_ty expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; return UnaryOp(Not, expression, LINENO(n), n->n_col_offset, c->c_arena); } case comparison: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { expr_ty expression; asdl_int_seq *ops; asdl_seq *cmps; ops = asdl_int_seq_new(NCH(n) / 2, c->c_arena); if (!ops) return NULL; cmps = asdl_seq_new(NCH(n) / 2, c->c_arena); if (!cmps) { return NULL; } for (i = 1; i < NCH(n); i += 2) { cmpop_ty newoperator; newoperator = ast_for_comp_op(c, CHILD(n, i)); if (!newoperator) { return NULL; } expression = ast_for_expr(c, CHILD(n, i + 1)); if (!expression) { return NULL; } asdl_seq_SET(ops, i / 2, newoperator); asdl_seq_SET(cmps, i / 2, expression); } expression = ast_for_expr(c, CHILD(n, 0)); if (!expression) { return NULL; } return Compare(expression, ops, cmps, LINENO(n), n->n_col_offset, c->c_arena); } break; /* The next five cases all handle BinOps. The main body of code is the same in each case, but the switch turned inside out to reuse the code for each type of operator. */ case expr: case xor_expr: case and_expr: case shift_expr: case arith_expr: case term: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } return ast_for_binop(c, n); case yield_expr: { expr_ty exp = NULL; if (NCH(n) == 2) { exp = ast_for_testlist(c, CHILD(n, 1)); if (!exp) return NULL; } return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena); } case factor: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } return ast_for_factor(c, n); case power: return ast_for_power(c, n); default: PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n)); return NULL; } /* should never get here unless if error is set */ return NULL; } static expr_ty ast_for_call(struct compiling *c, const node *n, expr_ty func) { /* arglist: (argument ',')* (argument [',']| '*' test [',' '**' test] | '**' test) argument: [test '='] test [comp_for] # Really [keyword '='] test */ int i, nargs, nkeywords, ngens; asdl_seq *args; asdl_seq *keywords; expr_ty vararg = NULL, kwarg = NULL; REQ(n, arglist); nargs = 0; nkeywords = 0; ngens = 0; for (i = 0; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) == argument) { if (NCH(ch) == 1) nargs++; else if (TYPE(CHILD(ch, 1)) == comp_for) ngens++; else nkeywords++; } } if (ngens > 1 || (ngens && (nargs || nkeywords))) { ast_error(n, "Generator expression must be parenthesized " "if not sole argument"); return NULL; } if (nargs + nkeywords + ngens > 255) { ast_error(n, "more than 255 arguments"); return NULL; } args = asdl_seq_new(nargs + ngens, c->c_arena); if (!args) return NULL; keywords = asdl_seq_new(nkeywords, c->c_arena); if (!keywords) return NULL; nargs = 0; nkeywords = 0; for (i = 0; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) == argument) { expr_ty e; if (NCH(ch) == 1) { if (nkeywords) { ast_error(CHILD(ch, 0), "non-keyword arg after keyword arg"); return NULL; } if (vararg) { ast_error(CHILD(ch, 0), "only named arguments may follow *expression"); return NULL; } e = ast_for_expr(c, CHILD(ch, 0)); if (!e) return NULL; asdl_seq_SET(args, nargs++, e); } else if (TYPE(CHILD(ch, 1)) == comp_for) { e = ast_for_genexp(c, ch); if (!e) return NULL; asdl_seq_SET(args, nargs++, e); } else { keyword_ty kw; identifier key; int k; char *tmp; /* CHILD(ch, 0) is test, but must be an identifier? */ e = ast_for_expr(c, CHILD(ch, 0)); if (!e) return NULL; /* f(lambda x: x[0] = 3) ends up getting parsed with * LHS test = lambda x: x[0], and RHS test = 3. * SF bug 132313 points out that complaining about a keyword * then is very confusing. */ if (e->kind == Lambda_kind) { ast_error(CHILD(ch, 0), "lambda cannot contain assignment"); return NULL; } else if (e->kind != Name_kind) { ast_error(CHILD(ch, 0), "keyword can't be an expression"); return NULL; } key = e->v.Name.id; if (!forbidden_check(c, CHILD(ch, 0), PyUnicode_AsUTF8(key))) return NULL; for (k = 0; k < nkeywords; k++) { tmp = _PyUnicode_AsString( ((keyword_ty)asdl_seq_GET(keywords, k))->arg); if (!strcmp(tmp, _PyUnicode_AsString(key))) { ast_error(CHILD(ch, 0), "keyword argument repeated"); return NULL; } } e = ast_for_expr(c, CHILD(ch, 2)); if (!e) return NULL; kw = keyword(key, e, c->c_arena); if (!kw) return NULL; asdl_seq_SET(keywords, nkeywords++, kw); } } else if (TYPE(ch) == STAR) { vararg = ast_for_expr(c, CHILD(n, i+1)); if (!vararg) return NULL; i++; } else if (TYPE(ch) == DOUBLESTAR) { kwarg = ast_for_expr(c, CHILD(n, i+1)); if (!kwarg) return NULL; i++; } } return Call(func, args, keywords, vararg, kwarg, func->lineno, func->col_offset, c->c_arena); } static expr_ty ast_for_testlist(struct compiling *c, const node* n) { /* testlist_comp: test (',' test)* [','] */ /* testlist: test (',' test)* [','] */ /* testlist_safe: test (',' test)+ [','] */ /* testlist1: test (',' test)* */ assert(NCH(n) > 0); if (TYPE(n) == testlist_comp) { if (NCH(n) > 1) assert(TYPE(CHILD(n, 1)) != comp_for); } else { assert(TYPE(n) == testlist || TYPE(n) == testlist_safe || TYPE(n) == testlist1); } if (NCH(n) == 1) return ast_for_expr(c, CHILD(n, 0)); else { asdl_seq *tmp = seq_for_testlist(c, n); if (!tmp) return NULL; return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena); } } static expr_ty ast_for_testlist_comp(struct compiling *c, const node* n) { /* testlist_comp: test ( comp_for | (',' test)* [','] ) */ /* argument: test [ comp_for ] */ assert(TYPE(n) == testlist_comp || TYPE(n) == argument); if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == comp_for) return ast_for_genexp(c, n); return ast_for_testlist(c, n); } /* like ast_for_testlist() but returns a sequence */ static asdl_seq* ast_for_class_bases(struct compiling *c, const node* n) { /* testlist: test (',' test)* [','] */ assert(NCH(n) > 0); REQ(n, testlist); if (NCH(n) == 1) { expr_ty base; asdl_seq *bases = asdl_seq_new(1, c->c_arena); if (!bases) return NULL; base = ast_for_expr(c, CHILD(n, 0)); if (!base) return NULL; asdl_seq_SET(bases, 0, base); return bases; } return seq_for_testlist(c, n); } static stmt_ty ast_for_expr_stmt(struct compiling *c, const node *n) { int num; REQ(n, expr_stmt); /* expr_stmt: testlist (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist))* [TYPE_COMMENT]) testlist: test (',' test)* [','] augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' test: ... here starts the operator precendence dance */ num = NCH(n); if (num == 1 || (num == 2 && TYPE(CHILD(n, 1)) == TYPE_COMMENT)) { expr_ty e = ast_for_testlist(c, CHILD(n, 0)); if (!e) return NULL; return Expr(e, LINENO(n), n->n_col_offset, c->c_arena); } else if (TYPE(CHILD(n, 1)) == augassign) { expr_ty expr1, expr2; operator_ty newoperator; node *ch = CHILD(n, 0); expr1 = ast_for_testlist(c, ch); if (!expr1) return NULL; if(!set_context(c, expr1, Store, ch)) return NULL; /* set_context checks that most expressions are not the left side. Augmented assignments can only have a name, a subscript, or an attribute on the left, though, so we have to explicitly check for those. */ switch (expr1->kind) { case Name_kind: case Attribute_kind: case Subscript_kind: break; default: ast_error(ch, "illegal expression for augmented assignment"); return NULL; } ch = CHILD(n, 2); if (TYPE(ch) == testlist) expr2 = ast_for_testlist(c, ch); else expr2 = ast_for_expr(c, ch); if (!expr2) return NULL; newoperator = ast_for_augassign(c, CHILD(n, 1)); if (!newoperator) return NULL; return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset, c->c_arena); } else { int i, nch_minus_type, has_type_comment; asdl_seq *targets; node *value; expr_ty expression; string type_comment; /* a normal assignment */ REQ(CHILD(n, 1), EQUAL); has_type_comment = TYPE(CHILD(n, num - 1)) == TYPE_COMMENT; nch_minus_type = num - has_type_comment; targets = asdl_seq_new(nch_minus_type / 2, c->c_arena); if (!targets) return NULL; for (i = 0; i < nch_minus_type - 2; i += 2) { expr_ty e; node *ch = CHILD(n, i); if (TYPE(ch) == yield_expr) { ast_error(ch, "assignment to yield expression not possible"); return NULL; } e = ast_for_testlist(c, ch); if (!e) return NULL; /* set context to assign */ if (!set_context(c, e, Store, CHILD(n, i))) return NULL; asdl_seq_SET(targets, i / 2, e); } value = CHILD(n, nch_minus_type - 1); if (TYPE(value) == testlist) expression = ast_for_testlist(c, value); else expression = ast_for_expr(c, value); if (!expression) return NULL; if (has_type_comment) type_comment = NEW_TYPE_COMMENT(CHILD(n, nch_minus_type)); else type_comment = NULL; return Assign(targets, expression, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } } static stmt_ty ast_for_print_stmt(struct compiling *c, const node *n) { /* print_stmt: 'print' ( [ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ] ) */ expr_ty dest = NULL, expression; asdl_seq *seq = NULL; bool nl; int i, j, values_count, start = 1; REQ(n, print_stmt); if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) { dest = ast_for_expr(c, CHILD(n, 2)); if (!dest) return NULL; start = 4; } values_count = (NCH(n) + 1 - start) / 2; if (values_count) { seq = asdl_seq_new(values_count, c->c_arena); if (!seq) return NULL; for (i = start, j = 0; i < NCH(n); i += 2, ++j) { expression = ast_for_expr(c, CHILD(n, i)); if (!expression) return NULL; asdl_seq_SET(seq, j, expression); } } nl = (TYPE(CHILD(n, NCH(n) - 1)) == COMMA) ? false : true; return Print(dest, seq, nl, LINENO(n), n->n_col_offset, c->c_arena); } static asdl_seq * ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context) { asdl_seq *seq; int i; expr_ty e; REQ(n, exprlist); seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { e = ast_for_expr(c, CHILD(n, i)); if (!e) return NULL; asdl_seq_SET(seq, i / 2, e); if (context && !set_context(c, e, context, CHILD(n, i))) return NULL; } return seq; } static stmt_ty ast_for_del_stmt(struct compiling *c, const node *n) { asdl_seq *expr_list; /* del_stmt: 'del' exprlist */ REQ(n, del_stmt); expr_list = ast_for_exprlist(c, CHILD(n, 1), Del); if (!expr_list) return NULL; return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_flow_stmt(struct compiling *c, const node *n) { /* flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt break_stmt: 'break' continue_stmt: 'continue' return_stmt: 'return' [testlist] yield_stmt: yield_expr yield_expr: 'yield' testlist raise_stmt: 'raise' [test [',' test [',' test]]] */ node *ch; REQ(n, flow_stmt); ch = CHILD(n, 0); switch (TYPE(ch)) { case break_stmt: return Break(LINENO(n), n->n_col_offset, c->c_arena); case continue_stmt: return Continue(LINENO(n), n->n_col_offset, c->c_arena); case yield_stmt: { /* will reduce to yield_expr */ expr_ty exp = ast_for_expr(c, CHILD(ch, 0)); if (!exp) return NULL; return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena); } case return_stmt: if (NCH(ch) == 1) return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena); else { expr_ty expression = ast_for_testlist(c, CHILD(ch, 1)); if (!expression) return NULL; return Return(expression, LINENO(n), n->n_col_offset, c->c_arena); } case raise_stmt: if (NCH(ch) == 1) return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); else if (NCH(ch) == 2) { expr_ty expression = ast_for_expr(c, CHILD(ch, 1)); if (!expression) return NULL; return Raise(expression, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(ch) == 4) { expr_ty expr1, expr2; expr1 = ast_for_expr(c, CHILD(ch, 1)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(ch, 3)); if (!expr2) return NULL; return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(ch) == 6) { expr_ty expr1, expr2, expr3; expr1 = ast_for_expr(c, CHILD(ch, 1)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(ch, 3)); if (!expr2) return NULL; expr3 = ast_for_expr(c, CHILD(ch, 5)); if (!expr3) return NULL; return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset, c->c_arena); } default: PyErr_Format(PyExc_SystemError, "unexpected flow_stmt: %d", TYPE(ch)); return NULL; } } static alias_ty alias_for_import_name(struct compiling *c, const node *n, int store) { /* import_as_name: NAME ['as' NAME] dotted_as_name: dotted_name ['as' NAME] dotted_name: NAME ('.' NAME)* */ PyObject *str, *name; loop: switch (TYPE(n)) { case import_as_name: { node *name_node = CHILD(n, 0); str = NULL; if (NCH(n) == 3) { node *str_node = CHILD(n, 2); if (store && !forbidden_check(c, str_node, STR(str_node))) return NULL; str = NEW_IDENTIFIER(str_node); if (!str) return NULL; } else { if (!forbidden_check(c, name_node, STR(name_node))) return NULL; } name = NEW_IDENTIFIER(name_node); if (!name) return NULL; return alias(name, str, c->c_arena); } case dotted_as_name: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { node *asname_node = CHILD(n, 2); alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0); if (!a) return NULL; assert(!a->asname); if (!forbidden_check(c, asname_node, STR(asname_node))) return NULL; a->asname = NEW_IDENTIFIER(asname_node); if (!a->asname) return NULL; return a; } break; case dotted_name: if (NCH(n) == 1) { node *name_node = CHILD(n, 0); if (store && !forbidden_check(c, name_node, STR(name_node))) return NULL; name = NEW_IDENTIFIER(name_node); if (!name) return NULL; return alias(name, NULL, c->c_arena); } else { /* Create a string of the form "a.b.c" */ int i; size_t len; char *s; PyObject *uni; len = 0; for (i = 0; i < NCH(n); i += 2) /* length of string plus one for the dot */ len += strlen(STR(CHILD(n, i))) + 1; len--; /* the last name doesn't have a dot */ str = PyBytes_FromStringAndSize(NULL, len); if (!str) return NULL; s = PyBytes_AS_STRING(str); if (!s) return NULL; for (i = 0; i < NCH(n); i += 2) { char *sch = STR(CHILD(n, i)); strcpy(s, STR(CHILD(n, i))); s += strlen(sch); *s++ = '.'; } --s; *s = '\0'; uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL); Py_DECREF(str); if (!uni) return NULL; str = uni; PyUnicode_InternInPlace(&str); if (PyArena_AddPyObject(c->c_arena, str) < 0) { Py_DECREF(str); return NULL; } return alias(str, NULL, c->c_arena); } break; case STAR: str = PyUnicode_InternFromString("*"); if (PyArena_AddPyObject(c->c_arena, str) < 0) { Py_DECREF(str); return NULL; } return alias(str, NULL, c->c_arena); default: PyErr_Format(PyExc_SystemError, "unexpected import name: %d", TYPE(n)); return NULL; } PyErr_SetString(PyExc_SystemError, "unhandled import name condition"); return NULL; } static stmt_ty ast_for_import_stmt(struct compiling *c, const node *n) { /* import_stmt: import_name | import_from import_name: 'import' dotted_as_names import_from: 'from' ('.'* dotted_name | '.') 'import' ('*' | '(' import_as_names ')' | import_as_names) */ int lineno; int col_offset; int i; asdl_seq *aliases; REQ(n, import_stmt); lineno = LINENO(n); col_offset = n->n_col_offset; n = CHILD(n, 0); if (TYPE(n) == import_name) { n = CHILD(n, 1); REQ(n, dotted_as_names); aliases = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!aliases) return NULL; for (i = 0; i < NCH(n); i += 2) { alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, i / 2, import_alias); } return Import(aliases, lineno, col_offset, c->c_arena); } else if (TYPE(n) == import_from) { int n_children; int idx, ndots = 0; alias_ty mod = NULL; identifier modname = NULL; /* Count the number of dots (for relative imports) and check for the optional module name */ for (idx = 1; idx < NCH(n); idx++) { if (TYPE(CHILD(n, idx)) == dotted_name) { mod = alias_for_import_name(c, CHILD(n, idx), 0); if (!mod) return NULL; idx++; break; } else if (TYPE(CHILD(n, idx)) != DOT) { break; } ndots++; } idx++; /* skip over the 'import' keyword */ switch (TYPE(CHILD(n, idx))) { case STAR: /* from ... import * */ n = CHILD(n, idx); n_children = 1; break; case LPAR: /* from ... import (x, y, z) */ n = CHILD(n, idx + 1); n_children = NCH(n); break; case import_as_names: /* from ... import x, y, z */ n = CHILD(n, idx); n_children = NCH(n); if (n_children % 2 == 0) { ast_error(n, "trailing comma not allowed without" " surrounding parentheses"); return NULL; } break; default: ast_error(n, "Unexpected node-type in from-import"); return NULL; } aliases = asdl_seq_new((n_children + 1) / 2, c->c_arena); if (!aliases) return NULL; /* handle "from ... import *" special b/c there's no children */ if (TYPE(n) == STAR) { alias_ty import_alias = alias_for_import_name(c, n, 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, 0, import_alias); } else { for (i = 0; i < NCH(n); i += 2) { alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, i / 2, import_alias); } } if (mod != NULL) modname = mod->name; return ImportFrom(modname, aliases, ndots, lineno, col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unknown import statement: starts with command '%s'", STR(CHILD(n, 0))); return NULL; } static stmt_ty ast_for_global_stmt(struct compiling *c, const node *n) { /* global_stmt: 'global' NAME (',' NAME)* */ identifier name; asdl_seq *s; int i; REQ(n, global_stmt); s = asdl_seq_new(NCH(n) / 2, c->c_arena); if (!s) return NULL; for (i = 1; i < NCH(n); i += 2) { name = NEW_IDENTIFIER(CHILD(n, i)); if (!name) return NULL; asdl_seq_SET(s, i / 2, name); } return Global(s, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_exec_stmt(struct compiling *c, const node *n) { expr_ty expr1, globals = NULL, locals = NULL; int n_children = NCH(n); if (n_children != 2 && n_children != 4 && n_children != 6) { PyErr_Format(PyExc_SystemError, "poorly formed 'exec' statement: %d parts to statement", n_children); return NULL; } /* exec_stmt: 'exec' expr ['in' test [',' test]] */ REQ(n, exec_stmt); expr1 = ast_for_expr(c, CHILD(n, 1)); if (!expr1) return NULL; if (expr1->kind == Tuple_kind && n_children < 4 && (asdl_seq_LEN(expr1->v.Tuple.elts) == 2 || asdl_seq_LEN(expr1->v.Tuple.elts) == 3)) { /* Backwards compatibility: passing exec args as a tuple */ globals = asdl_seq_GET(expr1->v.Tuple.elts, 1); if (asdl_seq_LEN(expr1->v.Tuple.elts) == 3) { locals = asdl_seq_GET(expr1->v.Tuple.elts, 2); } expr1 = asdl_seq_GET(expr1->v.Tuple.elts, 0); } if (n_children >= 4) { globals = ast_for_expr(c, CHILD(n, 3)); if (!globals) return NULL; } if (n_children == 6) { locals = ast_for_expr(c, CHILD(n, 5)); if (!locals) return NULL; } return Exec(expr1, globals, locals, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_assert_stmt(struct compiling *c, const node *n) { /* assert_stmt: 'assert' test [',' test] */ REQ(n, assert_stmt); if (NCH(n) == 2) { expr_ty expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; return Assert(expression, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(n) == 4) { expr_ty expr1, expr2; expr1 = ast_for_expr(c, CHILD(n, 1)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(n, 3)); if (!expr2) return NULL; return Assert(expr1, expr2, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "improper number of parts to 'assert' statement: %d", NCH(n)); return NULL; } static asdl_seq * ast_for_suite(struct compiling *c, const node *n) { /* suite: simple_stmt | NEWLINE [TYPE_COMMENT NEWLINE] INDENT stmt+ DEDENT */ asdl_seq *seq; stmt_ty s; int i, total, num, end, pos = 0; node *ch; REQ(n, suite); total = num_stmts(n); seq = asdl_seq_new(total, c->c_arena); if (!seq) return NULL; if (TYPE(CHILD(n, 0)) == simple_stmt) { n = CHILD(n, 0); /* simple_stmt always ends with a NEWLINE, and may have a trailing SEMI */ end = NCH(n) - 1; if (TYPE(CHILD(n, end - 1)) == SEMI) end--; /* loop by 2 to skip semi-colons */ for (i = 0; i < end; i += 2) { ch = CHILD(n, i); s = ast_for_stmt(c, ch); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } } else { i = 2; if (TYPE(CHILD(n, 1)) == TYPE_COMMENT) i += 2; for (; i < (NCH(n) - 1); i++) { ch = CHILD(n, i); REQ(ch, stmt); num = num_stmts(ch); if (num == 1) { /* small_stmt or compound_stmt with only one child */ s = ast_for_stmt(c, ch); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } else { int j; ch = CHILD(ch, 0); REQ(ch, simple_stmt); for (j = 0; j < NCH(ch); j += 2) { /* statement terminates with a semi-colon ';' */ if (NCH(CHILD(ch, j)) == 0) { assert((j + 1) == NCH(ch)); break; } s = ast_for_stmt(c, CHILD(ch, j)); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } } } } assert(pos == seq->size); return seq; } static stmt_ty ast_for_if_stmt(struct compiling *c, const node *n) { /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */ char *s; REQ(n, if_stmt); if (NCH(n) == 4) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return If(expression, suite_seq, NULL, LINENO(n), n->n_col_offset, c->c_arena); } s = STR(CHILD(n, 4)); /* s[2], the third character in the string, will be 's' for el_s_e, or 'i' for el_i_f */ if (s[2] == 's') { expr_ty expression; asdl_seq *seq1, *seq2; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; seq1 = ast_for_suite(c, CHILD(n, 3)); if (!seq1) return NULL; seq2 = ast_for_suite(c, CHILD(n, 6)); if (!seq2) return NULL; return If(expression, seq1, seq2, LINENO(n), n->n_col_offset, c->c_arena); } else if (s[2] == 'i') { int i, n_elif, has_else = 0; expr_ty expression; asdl_seq *suite_seq; asdl_seq *orelse = NULL; n_elif = NCH(n) - 4; /* must reference the child n_elif+1 since 'else' token is third, not fourth, child from the end. */ if (TYPE(CHILD(n, (n_elif + 1))) == NAME && STR(CHILD(n, (n_elif + 1)))[2] == 's') { has_else = 1; n_elif -= 3; } n_elif /= 4; if (has_else) { asdl_seq *suite_seq2; orelse = asdl_seq_new(1, c->c_arena); if (!orelse) return NULL; expression = ast_for_expr(c, CHILD(n, NCH(n) - 6)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, NCH(n) - 4)); if (!suite_seq) return NULL; suite_seq2 = ast_for_suite(c, CHILD(n, NCH(n) - 1)); if (!suite_seq2) return NULL; asdl_seq_SET(orelse, 0, If(expression, suite_seq, suite_seq2, LINENO(CHILD(n, NCH(n) - 6)), CHILD(n, NCH(n) - 6)->n_col_offset, c->c_arena)); /* the just-created orelse handled the last elif */ n_elif--; } for (i = 0; i < n_elif; i++) { int off = 5 + (n_elif - i - 1) * 4; asdl_seq *newobj = asdl_seq_new(1, c->c_arena); if (!newobj) return NULL; expression = ast_for_expr(c, CHILD(n, off)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, off + 2)); if (!suite_seq) return NULL; asdl_seq_SET(newobj, 0, If(expression, suite_seq, orelse, LINENO(CHILD(n, off)), CHILD(n, off)->n_col_offset, c->c_arena)); orelse = newobj; } expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return If(expression, suite_seq, orelse, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unexpected token in 'if' statement: %s", s); return NULL; } static stmt_ty ast_for_while_stmt(struct compiling *c, const node *n) { /* while_stmt: 'while' test ':' suite ['else' ':' suite] */ REQ(n, while_stmt); if (NCH(n) == 4) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return While(expression, suite_seq, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(n) == 7) { expr_ty expression; asdl_seq *seq1, *seq2; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; seq1 = ast_for_suite(c, CHILD(n, 3)); if (!seq1) return NULL; seq2 = ast_for_suite(c, CHILD(n, 6)); if (!seq2) return NULL; return While(expression, seq1, seq2, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "wrong number of tokens for 'while' statement: %d", NCH(n)); return NULL; } static stmt_ty ast_for_for_stmt(struct compiling *c, const node *n) { asdl_seq *_target, *seq = NULL, *suite_seq; expr_ty expression; expr_ty target, first; const node *node_target; int has_type_comment; string type_comment; /* for_stmt: 'for' exprlist 'in' testlist ':' [TYPE_COMMENT] suite ['else' ':' suite] */ REQ(n, for_stmt); has_type_comment = TYPE(CHILD(n, 5)) == TYPE_COMMENT; if (NCH(n) == 9 + has_type_comment) { seq = ast_for_suite(c, CHILD(n, 8 + has_type_comment)); if (!seq) return NULL; } node_target = CHILD(n, 1); _target = ast_for_exprlist(c, node_target, Store); if (!_target) return NULL; /* Check the # of children rather than the length of _target, since for x, in ... has 1 element in _target, but still requires a Tuple. */ first = (expr_ty)asdl_seq_GET(_target, 0); if (NCH(node_target) == 1) target = first; else target = Tuple(_target, Store, first->lineno, first->col_offset, c->c_arena); expression = ast_for_testlist(c, CHILD(n, 3)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 5 + has_type_comment)); if (!suite_seq) return NULL; if (has_type_comment) type_comment = NEW_TYPE_COMMENT(CHILD(n, 5)); else type_comment = NULL; return For(target, expression, suite_seq, seq, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } static excepthandler_ty ast_for_except_clause(struct compiling *c, const node *exc, node *body) { /* except_clause: 'except' [test [(',' | 'as') test]] */ REQ(exc, except_clause); REQ(body, suite); if (NCH(exc) == 1) { asdl_seq *suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(NULL, NULL, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } else if (NCH(exc) == 2) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(exc, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(expression, NULL, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } else if (NCH(exc) == 4) { asdl_seq *suite_seq; expr_ty expression; expr_ty e = ast_for_expr(c, CHILD(exc, 3)); if (!e) return NULL; if (!set_context(c, e, Store, CHILD(exc, 3))) return NULL; expression = ast_for_expr(c, CHILD(exc, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(expression, e, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "wrong number of children for 'except' clause: %d", NCH(exc)); return NULL; } static stmt_ty ast_for_try_stmt(struct compiling *c, const node *n) { const int nch = NCH(n); int n_except = (nch - 3)/3; asdl_seq *body, *orelse = NULL, *finally = NULL; REQ(n, try_stmt); body = ast_for_suite(c, CHILD(n, 2)); if (body == NULL) return NULL; if (TYPE(CHILD(n, nch - 3)) == NAME) { if (strcmp(STR(CHILD(n, nch - 3)), "finally") == 0) { if (nch >= 9 && TYPE(CHILD(n, nch - 6)) == NAME) { /* we can assume it's an "else", because nch >= 9 for try-else-finally and it would otherwise have a type of except_clause */ orelse = ast_for_suite(c, CHILD(n, nch - 4)); if (orelse == NULL) return NULL; n_except--; } finally = ast_for_suite(c, CHILD(n, nch - 1)); if (finally == NULL) return NULL; n_except--; } else { /* we can assume it's an "else", otherwise it would have a type of except_clause */ orelse = ast_for_suite(c, CHILD(n, nch - 1)); if (orelse == NULL) return NULL; n_except--; } } else if (TYPE(CHILD(n, nch - 3)) != except_clause) { ast_error(n, "malformed 'try' statement"); return NULL; } if (n_except > 0) { int i; stmt_ty except_st; /* process except statements to create a try ... except */ asdl_seq *handlers = asdl_seq_new(n_except, c->c_arena); if (handlers == NULL) return NULL; for (i = 0; i < n_except; i++) { excepthandler_ty e = ast_for_except_clause(c, CHILD(n, 3 + i * 3), CHILD(n, 5 + i * 3)); if (!e) return NULL; asdl_seq_SET(handlers, i, e); } except_st = TryExcept(body, handlers, orelse, LINENO(n), n->n_col_offset, c->c_arena); if (!finally) return except_st; /* if a 'finally' is present too, we nest the TryExcept within a TryFinally to emulate try ... except ... finally */ body = asdl_seq_new(1, c->c_arena); if (body == NULL) return NULL; asdl_seq_SET(body, 0, except_st); } /* must be a try ... finally (except clauses are in body, if any exist) */ assert(finally != NULL); return TryFinally(body, finally, LINENO(n), n->n_col_offset, c->c_arena); } /* with_item: test ['as' expr] */ static stmt_ty ast_for_with_item(struct compiling *c, const node *n, asdl_seq *content, string type_comment) { expr_ty context_expr, optional_vars = NULL; REQ(n, with_item); context_expr = ast_for_expr(c, CHILD(n, 0)); if (!context_expr) return NULL; if (NCH(n) == 3) { optional_vars = ast_for_expr(c, CHILD(n, 2)); if (!optional_vars) { return NULL; } if (!set_context(c, optional_vars, Store, n)) { return NULL; } } return With(context_expr, optional_vars, content, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } /* with_stmt: 'with' with_item (',' with_item)* ':' [TYPE_COMMENT] suite */ static stmt_ty ast_for_with_stmt(struct compiling *c, const node *n) { int i, has_type_comment; stmt_ty ret; asdl_seq *inner; string type_comment; REQ(n, with_stmt); has_type_comment = TYPE(CHILD(n, NCH(n) - 2)) == TYPE_COMMENT; /* process the with items inside-out */ i = NCH(n) - 1; /* the suite of the innermost with item is the suite of the with stmt */ inner = ast_for_suite(c, CHILD(n, i)); if (!inner) return NULL; if (has_type_comment) { type_comment = NEW_TYPE_COMMENT(CHILD(n, NCH(n) - 2)); i--; } else type_comment = NULL; for (;;) { i -= 2; ret = ast_for_with_item(c, CHILD(n, i), inner, type_comment); if (!ret) return NULL; /* was this the last item? */ if (i == 1) break; /* if not, wrap the result so far in a new sequence */ inner = asdl_seq_new(1, c->c_arena); if (!inner) return NULL; asdl_seq_SET(inner, 0, ret); } return ret; } static stmt_ty ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) { /* classdef: 'class' NAME ['(' testlist ')'] ':' suite */ PyObject *classname; asdl_seq *bases, *s; REQ(n, classdef); if (!forbidden_check(c, n, STR(CHILD(n, 1)))) return NULL; if (NCH(n) == 4) { s = ast_for_suite(c, CHILD(n, 3)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; return ClassDef(classname, NULL, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } /* check for empty base list */ if (TYPE(CHILD(n,3)) == RPAR) { s = ast_for_suite(c, CHILD(n,5)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; return ClassDef(classname, NULL, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } /* else handle the base class list */ bases = ast_for_class_bases(c, CHILD(n, 3)); if (!bases) return NULL; s = ast_for_suite(c, CHILD(n, 6)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; return ClassDef(classname, bases, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_stmt(struct compiling *c, const node *n) { if (TYPE(n) == stmt) { assert(NCH(n) == 1); n = CHILD(n, 0); } if (TYPE(n) == simple_stmt) { assert(num_stmts(n) == 1); n = CHILD(n, 0); } if (TYPE(n) == small_stmt) { n = CHILD(n, 0); /* small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt */ switch (TYPE(n)) { case expr_stmt: return ast_for_expr_stmt(c, n); case print_stmt: return ast_for_print_stmt(c, n); case del_stmt: return ast_for_del_stmt(c, n); case pass_stmt: return Pass(LINENO(n), n->n_col_offset, c->c_arena); case flow_stmt: return ast_for_flow_stmt(c, n); case import_stmt: return ast_for_import_stmt(c, n); case global_stmt: return ast_for_global_stmt(c, n); case exec_stmt: return ast_for_exec_stmt(c, n); case assert_stmt: return ast_for_assert_stmt(c, n); default: PyErr_Format(PyExc_SystemError, "unhandled small_stmt: TYPE=%d NCH=%d\n", TYPE(n), NCH(n)); return NULL; } } else { /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef | decorated */ node *ch = CHILD(n, 0); REQ(n, compound_stmt); switch (TYPE(ch)) { case if_stmt: return ast_for_if_stmt(c, ch); case while_stmt: return ast_for_while_stmt(c, ch); case for_stmt: return ast_for_for_stmt(c, ch); case try_stmt: return ast_for_try_stmt(c, ch); case with_stmt: return ast_for_with_stmt(c, ch); case funcdef: return ast_for_funcdef(c, ch, NULL); case classdef: return ast_for_classdef(c, ch, NULL); case decorated: return ast_for_decorated(c, ch); default: PyErr_Format(PyExc_SystemError, "unhandled small_stmt: TYPE=%d NCH=%d\n", TYPE(n), NCH(n)); return NULL; } } } static PyObject * parsenumber(struct compiling *c, const char *s) { const char *end; long x; double dx; int old_style_octal; #ifndef WITHOUT_COMPLEX Py_complex complex; int imflag; #endif assert(s != NULL); errno = 0; end = s + strlen(s) - 1; #ifndef WITHOUT_COMPLEX imflag = *end == 'j' || *end == 'J'; #endif if (*end == 'l' || *end == 'L') { /* Make a copy without the trailing 'L' */ size_t len = end - s + 1; char *copy = malloc(len); PyObject *result; if (copy == NULL) return PyErr_NoMemory(); memcpy(copy, s, len); copy[len - 1] = '\0'; old_style_octal = len > 2 && copy[0] == '0' && copy[1] >= '0' && copy[1] <= '9'; result = PyLong_FromString(copy, (char **)0, old_style_octal ? 8 : 0); free(copy); return result; } x = Ta27OS_strtol((char *)s, (char **)&end, 0); if (*end == '\0') { if (errno != 0) { old_style_octal = end - s > 1 && s[0] == '0' && s[1] >= '0' && s[1] <= '9'; return PyLong_FromString((char *)s, (char **)0, old_style_octal ? 8 : 0); } return PyLong_FromLong(x); } /* XXX Huge floats may silently fail */ #ifndef WITHOUT_COMPLEX if (imflag) { complex.real = 0.; complex.imag = PyOS_string_to_double(s, (char **)&end, NULL); if (complex.imag == -1.0 && PyErr_Occurred()) return NULL; return PyComplex_FromCComplex(complex); } else #endif { dx = PyOS_string_to_double(s, NULL, NULL); if (dx == -1.0 && PyErr_Occurred()) return NULL; return PyFloat_FromDouble(dx); } } /* adapted from Python 3.5.1 */ static PyObject * decode_utf8(struct compiling *c, const char **sPtr, const char *end) { #ifndef Py_USING_UNICODE Py_FatalError("decode_utf8 should not be called in this build."); return NULL; #else const char *s, *t; t = s = *sPtr; /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */ while (s < end && (*s & 0x80)) s++; *sPtr = s; return PyUnicode_DecodeUTF8(t, s - t, NULL); #endif } #ifdef Py_USING_UNICODE /* taken from Python 3.5.1 */ static PyObject * decode_unicode(struct compiling *c, const char *s, size_t len, int rawmode, const char *encoding) { PyObject *v, *u; char *buf; char *p; const char *end; if (encoding == NULL) { u = NULL; } else { /* check for integer overflow */ if (len > PY_SIZE_MAX / 6) return NULL; /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5 "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */ u = PyBytes_FromStringAndSize((char *)NULL, len * 6); if (u == NULL) return NULL; p = buf = PyBytes_AsString(u); end = s + len; while (s < end) { if (*s == '\\') { *p++ = *s++; if (*s & 0x80) { strcpy(p, "u005c"); p += 5; } } if (*s & 0x80) { /* XXX inefficient */ PyObject *w; int kind; void *data; Py_ssize_t len, i; w = decode_utf8(c, &s, end); if (w == NULL) { Py_DECREF(u); return NULL; } kind = PyUnicode_KIND(w); data = PyUnicode_DATA(w); len = PyUnicode_GET_LENGTH(w); for (i = 0; i < len; i++) { Py_UCS4 chr = PyUnicode_READ(kind, data, i); sprintf(p, "\\U%08x", chr); p += 10; } /* Should be impossible to overflow */ assert(p - buf <= Py_SIZE(u)); Py_DECREF(w); } else { *p++ = *s++; } } len = p - buf; s = buf; } if (rawmode) v = PyUnicode_DecodeRawUnicodeEscape(s, len, NULL); else v = PyUnicode_DecodeUnicodeEscape(s, len, NULL); Py_XDECREF(u); return v; } #endif /* s is a Python string literal, including the bracketing quote characters, * and r &/or u prefixes (if any), and embedded escape sequences (if any). * parsestr parses it, and returns the decoded Python string object. */ static PyObject * parsestr(struct compiling *c, const node *n, const char *s) { size_t len, i; int quote = Py_CHARMASK(*s); int rawmode = 0; int need_encoding; int unicode = c->c_future_unicode; int bytes = 0; if (isalpha(quote) || quote == '_') { if (quote == 'u' || quote == 'U') { quote = *++s; unicode = 1; } if (quote == 'b' || quote == 'B') { quote = *++s; unicode = 0; bytes = 1; } if (quote == 'r' || quote == 'R') { quote = *++s; rawmode = 1; } } if (quote != '\'' && quote != '\"') { PyErr_BadInternalCall(); return NULL; } s++; len = strlen(s); if (len > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "string to parse is too long"); return NULL; } if (s[--len] != quote) { PyErr_BadInternalCall(); return NULL; } if (len >= 4 && s[0] == quote && s[1] == quote) { s += 2; len -= 2; if (s[--len] != quote || s[--len] != quote) { PyErr_BadInternalCall(); return NULL; } } if (Py_Py3kWarningFlag && bytes) { for (i = 0; i < len; i++) { if ((unsigned char)s[i] > 127) { if (!ast_warn(c, n, "non-ascii bytes literals not supported in 3.x")) return NULL; break; } } } #ifdef Py_USING_UNICODE if (unicode || Py_UnicodeFlag) { return decode_unicode(c, s, len, rawmode, c->c_encoding); } #endif need_encoding = (c->c_encoding != NULL && strcmp(c->c_encoding, "utf-8") != 0 && strcmp(c->c_encoding, "iso-8859-1") != 0); if (rawmode || strchr(s, '\\') == NULL) { if (need_encoding) { #ifndef Py_USING_UNICODE /* This should not happen - we never see any other encoding. */ Py_FatalError( "cannot deal with encodings in this build."); #else PyObject *v, *u = PyUnicode_DecodeUTF8(s, len, NULL); if (u == NULL) return NULL; v = PyUnicode_AsEncodedString(u, c->c_encoding, NULL); Py_DECREF(u); return v; #endif } else { return PyBytes_FromStringAndSize(s, len); } } return PyBytes_DecodeEscape(s, len, NULL, 1, need_encoding ? c->c_encoding : NULL); } /* Build a Python string object out of a STRING atom. This takes care of * compile-time literal catenation, calling parsestr() on each piece, and * pasting the intermediate results together. */ static PyObject * parsestrplus(struct compiling *c, const node *n) { PyObject *v; int i; REQ(CHILD(n, 0), STRING); if ((v = parsestr(c, n, STR(CHILD(n, 0)))) != NULL) { /* String literal concatenation */ for (i = 1; i < NCH(n); i++) { PyObject *s; s = parsestr(c, n, STR(CHILD(n, i))); if (s == NULL) goto onError; if (PyBytes_Check(v) && PyBytes_Check(s)) { PyBytes_ConcatAndDel(&v, s); if (v == NULL) goto onError; } #ifdef Py_USING_UNICODE else { PyObject *temp; /* Python 2's PyUnicode_FromObject (which is * called on the arguments to PyUnicode_Concat) * automatically converts Bytes objects into * Str objects, but in Python 3 it throws a * syntax error. To allow mixed literal * concatenation e.g. "foo" u"bar" (which is * valid in Python 2), we have to explicitly * check for Bytes and convert manually. */ if (PyBytes_Check(s)) { temp = PyUnicode_FromEncodedObject(s, NULL, "strict"); Py_DECREF(s); s = temp; } if (PyBytes_Check(v)) { temp = PyUnicode_FromEncodedObject(v, NULL, "strict"); Py_DECREF(v); v = temp; } temp = PyUnicode_Concat(v, s); Py_DECREF(s); Py_DECREF(v); v = temp; if (v == NULL) goto onError; } #endif } } return v; onError: Py_XDECREF(v); return NULL; } typed-ast-1.1.0/ast27/Python/graminit.c0000644€Tøžæ€2›s®0000013115113050216645021123 0ustar ddfisher00000000000000/* Generated by Parser/pgen */ #include "pgenheaders.h" #include "grammar.h" grammar _Ta27Parser_Grammar; static arc arcs_0_0[3] = { {2, 1}, {3, 1}, {4, 2}, }; static arc arcs_0_1[1] = { {0, 1}, }; static arc arcs_0_2[1] = { {2, 1}, }; static state states_0[3] = { {3, arcs_0_0}, {1, arcs_0_1}, {1, arcs_0_2}, }; static arc arcs_1_0[3] = { {2, 0}, {6, 0}, {7, 1}, }; static arc arcs_1_1[1] = { {0, 1}, }; static state states_1[2] = { {3, arcs_1_0}, {1, arcs_1_1}, }; static arc arcs_2_0[1] = { {9, 1}, }; static arc arcs_2_1[2] = { {2, 1}, {7, 2}, }; static arc arcs_2_2[1] = { {0, 2}, }; static state states_2[3] = { {1, arcs_2_0}, {2, arcs_2_1}, {1, arcs_2_2}, }; static arc arcs_3_0[1] = { {11, 1}, }; static arc arcs_3_1[1] = { {12, 2}, }; static arc arcs_3_2[2] = { {13, 3}, {2, 4}, }; static arc arcs_3_3[2] = { {14, 5}, {15, 6}, }; static arc arcs_3_4[1] = { {0, 4}, }; static arc arcs_3_5[1] = { {15, 6}, }; static arc arcs_3_6[1] = { {2, 4}, }; static state states_3[7] = { {1, arcs_3_0}, {1, arcs_3_1}, {2, arcs_3_2}, {2, arcs_3_3}, {1, arcs_3_4}, {1, arcs_3_5}, {1, arcs_3_6}, }; static arc arcs_4_0[1] = { {10, 1}, }; static arc arcs_4_1[2] = { {10, 1}, {0, 1}, }; static state states_4[2] = { {1, arcs_4_0}, {2, arcs_4_1}, }; static arc arcs_5_0[1] = { {16, 1}, }; static arc arcs_5_1[2] = { {18, 2}, {19, 2}, }; static arc arcs_5_2[1] = { {0, 2}, }; static state states_5[3] = { {1, arcs_5_0}, {2, arcs_5_1}, {1, arcs_5_2}, }; static arc arcs_6_0[1] = { {20, 1}, }; static arc arcs_6_1[1] = { {21, 2}, }; static arc arcs_6_2[1] = { {22, 3}, }; static arc arcs_6_3[1] = { {23, 4}, }; static arc arcs_6_4[2] = { {24, 5}, {25, 6}, }; static arc arcs_6_5[1] = { {25, 6}, }; static arc arcs_6_6[1] = { {0, 6}, }; static state states_6[7] = { {1, arcs_6_0}, {1, arcs_6_1}, {1, arcs_6_2}, {1, arcs_6_3}, {2, arcs_6_4}, {1, arcs_6_5}, {1, arcs_6_6}, }; static arc arcs_7_0[1] = { {13, 1}, }; static arc arcs_7_1[2] = { {26, 2}, {15, 3}, }; static arc arcs_7_2[1] = { {15, 3}, }; static arc arcs_7_3[1] = { {0, 3}, }; static state states_7[4] = { {1, arcs_7_0}, {2, arcs_7_1}, {1, arcs_7_2}, {1, arcs_7_3}, }; static arc arcs_8_0[3] = { {27, 1}, {31, 2}, {32, 3}, }; static arc arcs_8_1[4] = { {28, 4}, {30, 5}, {24, 6}, {0, 1}, }; static arc arcs_8_2[1] = { {21, 7}, }; static arc arcs_8_3[1] = { {21, 8}, }; static arc arcs_8_4[1] = { {29, 9}, }; static arc arcs_8_5[5] = { {27, 1}, {24, 10}, {31, 2}, {32, 3}, {0, 5}, }; static arc arcs_8_6[1] = { {0, 6}, }; static arc arcs_8_7[3] = { {30, 11}, {24, 6}, {0, 7}, }; static arc arcs_8_8[2] = { {24, 6}, {0, 8}, }; static arc arcs_8_9[3] = { {30, 5}, {24, 6}, {0, 9}, }; static arc arcs_8_10[4] = { {27, 1}, {31, 2}, {32, 3}, {0, 10}, }; static arc arcs_8_11[2] = { {24, 12}, {32, 3}, }; static arc arcs_8_12[1] = { {32, 3}, }; static state states_8[13] = { {3, arcs_8_0}, {4, arcs_8_1}, {1, arcs_8_2}, {1, arcs_8_3}, {1, arcs_8_4}, {5, arcs_8_5}, {1, arcs_8_6}, {3, arcs_8_7}, {2, arcs_8_8}, {3, arcs_8_9}, {4, arcs_8_10}, {2, arcs_8_11}, {1, arcs_8_12}, }; static arc arcs_9_0[2] = { {21, 1}, {13, 2}, }; static arc arcs_9_1[1] = { {0, 1}, }; static arc arcs_9_2[1] = { {33, 3}, }; static arc arcs_9_3[1] = { {15, 1}, }; static state states_9[4] = { {2, arcs_9_0}, {1, arcs_9_1}, {1, arcs_9_2}, {1, arcs_9_3}, }; static arc arcs_10_0[1] = { {27, 1}, }; static arc arcs_10_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_10_2[2] = { {27, 1}, {0, 2}, }; static state states_10[3] = { {1, arcs_10_0}, {2, arcs_10_1}, {2, arcs_10_2}, }; static arc arcs_11_0[2] = { {3, 1}, {4, 1}, }; static arc arcs_11_1[1] = { {0, 1}, }; static state states_11[2] = { {2, arcs_11_0}, {1, arcs_11_1}, }; static arc arcs_12_0[1] = { {34, 1}, }; static arc arcs_12_1[2] = { {35, 2}, {2, 3}, }; static arc arcs_12_2[2] = { {34, 1}, {2, 3}, }; static arc arcs_12_3[1] = { {0, 3}, }; static state states_12[4] = { {1, arcs_12_0}, {2, arcs_12_1}, {2, arcs_12_2}, {1, arcs_12_3}, }; static arc arcs_13_0[9] = { {36, 1}, {37, 1}, {38, 1}, {39, 1}, {40, 1}, {41, 1}, {42, 1}, {43, 1}, {44, 1}, }; static arc arcs_13_1[1] = { {0, 1}, }; static state states_13[2] = { {9, arcs_13_0}, {1, arcs_13_1}, }; static arc arcs_14_0[1] = { {9, 1}, }; static arc arcs_14_1[4] = { {45, 2}, {28, 3}, {24, 4}, {0, 1}, }; static arc arcs_14_2[2] = { {46, 4}, {9, 4}, }; static arc arcs_14_3[2] = { {46, 5}, {9, 5}, }; static arc arcs_14_4[1] = { {0, 4}, }; static arc arcs_14_5[3] = { {28, 3}, {24, 4}, {0, 5}, }; static state states_14[6] = { {1, arcs_14_0}, {4, arcs_14_1}, {2, arcs_14_2}, {2, arcs_14_3}, {1, arcs_14_4}, {3, arcs_14_5}, }; static arc arcs_15_0[12] = { {47, 1}, {48, 1}, {49, 1}, {50, 1}, {51, 1}, {52, 1}, {53, 1}, {54, 1}, {55, 1}, {56, 1}, {57, 1}, {58, 1}, }; static arc arcs_15_1[1] = { {0, 1}, }; static state states_15[2] = { {12, arcs_15_0}, {1, arcs_15_1}, }; static arc arcs_16_0[1] = { {59, 1}, }; static arc arcs_16_1[3] = { {29, 2}, {60, 3}, {0, 1}, }; static arc arcs_16_2[2] = { {30, 4}, {0, 2}, }; static arc arcs_16_3[1] = { {29, 5}, }; static arc arcs_16_4[2] = { {29, 2}, {0, 4}, }; static arc arcs_16_5[2] = { {30, 6}, {0, 5}, }; static arc arcs_16_6[1] = { {29, 7}, }; static arc arcs_16_7[2] = { {30, 8}, {0, 7}, }; static arc arcs_16_8[2] = { {29, 7}, {0, 8}, }; static state states_16[9] = { {1, arcs_16_0}, {3, arcs_16_1}, {2, arcs_16_2}, {1, arcs_16_3}, {2, arcs_16_4}, {2, arcs_16_5}, {1, arcs_16_6}, {2, arcs_16_7}, {2, arcs_16_8}, }; static arc arcs_17_0[1] = { {61, 1}, }; static arc arcs_17_1[1] = { {62, 2}, }; static arc arcs_17_2[1] = { {0, 2}, }; static state states_17[3] = { {1, arcs_17_0}, {1, arcs_17_1}, {1, arcs_17_2}, }; static arc arcs_18_0[1] = { {63, 1}, }; static arc arcs_18_1[1] = { {0, 1}, }; static state states_18[2] = { {1, arcs_18_0}, {1, arcs_18_1}, }; static arc arcs_19_0[5] = { {64, 1}, {65, 1}, {66, 1}, {67, 1}, {68, 1}, }; static arc arcs_19_1[1] = { {0, 1}, }; static state states_19[2] = { {5, arcs_19_0}, {1, arcs_19_1}, }; static arc arcs_20_0[1] = { {69, 1}, }; static arc arcs_20_1[1] = { {0, 1}, }; static state states_20[2] = { {1, arcs_20_0}, {1, arcs_20_1}, }; static arc arcs_21_0[1] = { {70, 1}, }; static arc arcs_21_1[1] = { {0, 1}, }; static state states_21[2] = { {1, arcs_21_0}, {1, arcs_21_1}, }; static arc arcs_22_0[1] = { {71, 1}, }; static arc arcs_22_1[2] = { {9, 2}, {0, 1}, }; static arc arcs_22_2[1] = { {0, 2}, }; static state states_22[3] = { {1, arcs_22_0}, {2, arcs_22_1}, {1, arcs_22_2}, }; static arc arcs_23_0[1] = { {46, 1}, }; static arc arcs_23_1[1] = { {0, 1}, }; static state states_23[2] = { {1, arcs_23_0}, {1, arcs_23_1}, }; static arc arcs_24_0[1] = { {72, 1}, }; static arc arcs_24_1[2] = { {29, 2}, {0, 1}, }; static arc arcs_24_2[2] = { {30, 3}, {0, 2}, }; static arc arcs_24_3[1] = { {29, 4}, }; static arc arcs_24_4[2] = { {30, 5}, {0, 4}, }; static arc arcs_24_5[1] = { {29, 6}, }; static arc arcs_24_6[1] = { {0, 6}, }; static state states_24[7] = { {1, arcs_24_0}, {2, arcs_24_1}, {2, arcs_24_2}, {1, arcs_24_3}, {2, arcs_24_4}, {1, arcs_24_5}, {1, arcs_24_6}, }; static arc arcs_25_0[2] = { {73, 1}, {74, 1}, }; static arc arcs_25_1[1] = { {0, 1}, }; static state states_25[2] = { {2, arcs_25_0}, {1, arcs_25_1}, }; static arc arcs_26_0[1] = { {75, 1}, }; static arc arcs_26_1[1] = { {76, 2}, }; static arc arcs_26_2[1] = { {0, 2}, }; static state states_26[3] = { {1, arcs_26_0}, {1, arcs_26_1}, {1, arcs_26_2}, }; static arc arcs_27_0[1] = { {77, 1}, }; static arc arcs_27_1[2] = { {78, 2}, {12, 3}, }; static arc arcs_27_2[3] = { {78, 2}, {12, 3}, {75, 4}, }; static arc arcs_27_3[1] = { {75, 4}, }; static arc arcs_27_4[3] = { {31, 5}, {13, 6}, {79, 5}, }; static arc arcs_27_5[1] = { {0, 5}, }; static arc arcs_27_6[1] = { {79, 7}, }; static arc arcs_27_7[1] = { {15, 5}, }; static state states_27[8] = { {1, arcs_27_0}, {2, arcs_27_1}, {3, arcs_27_2}, {1, arcs_27_3}, {3, arcs_27_4}, {1, arcs_27_5}, {1, arcs_27_6}, {1, arcs_27_7}, }; static arc arcs_28_0[1] = { {21, 1}, }; static arc arcs_28_1[2] = { {81, 2}, {0, 1}, }; static arc arcs_28_2[1] = { {21, 3}, }; static arc arcs_28_3[1] = { {0, 3}, }; static state states_28[4] = { {1, arcs_28_0}, {2, arcs_28_1}, {1, arcs_28_2}, {1, arcs_28_3}, }; static arc arcs_29_0[1] = { {12, 1}, }; static arc arcs_29_1[2] = { {81, 2}, {0, 1}, }; static arc arcs_29_2[1] = { {21, 3}, }; static arc arcs_29_3[1] = { {0, 3}, }; static state states_29[4] = { {1, arcs_29_0}, {2, arcs_29_1}, {1, arcs_29_2}, {1, arcs_29_3}, }; static arc arcs_30_0[1] = { {80, 1}, }; static arc arcs_30_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_30_2[2] = { {80, 1}, {0, 2}, }; static state states_30[3] = { {1, arcs_30_0}, {2, arcs_30_1}, {2, arcs_30_2}, }; static arc arcs_31_0[1] = { {82, 1}, }; static arc arcs_31_1[2] = { {30, 0}, {0, 1}, }; static state states_31[2] = { {1, arcs_31_0}, {2, arcs_31_1}, }; static arc arcs_32_0[1] = { {21, 1}, }; static arc arcs_32_1[2] = { {78, 0}, {0, 1}, }; static state states_32[2] = { {1, arcs_32_0}, {2, arcs_32_1}, }; static arc arcs_33_0[1] = { {83, 1}, }; static arc arcs_33_1[1] = { {21, 2}, }; static arc arcs_33_2[2] = { {30, 1}, {0, 2}, }; static state states_33[3] = { {1, arcs_33_0}, {1, arcs_33_1}, {2, arcs_33_2}, }; static arc arcs_34_0[1] = { {84, 1}, }; static arc arcs_34_1[1] = { {85, 2}, }; static arc arcs_34_2[2] = { {86, 3}, {0, 2}, }; static arc arcs_34_3[1] = { {29, 4}, }; static arc arcs_34_4[2] = { {30, 5}, {0, 4}, }; static arc arcs_34_5[1] = { {29, 6}, }; static arc arcs_34_6[1] = { {0, 6}, }; static state states_34[7] = { {1, arcs_34_0}, {1, arcs_34_1}, {2, arcs_34_2}, {1, arcs_34_3}, {2, arcs_34_4}, {1, arcs_34_5}, {1, arcs_34_6}, }; static arc arcs_35_0[1] = { {87, 1}, }; static arc arcs_35_1[1] = { {29, 2}, }; static arc arcs_35_2[2] = { {30, 3}, {0, 2}, }; static arc arcs_35_3[1] = { {29, 4}, }; static arc arcs_35_4[1] = { {0, 4}, }; static state states_35[5] = { {1, arcs_35_0}, {1, arcs_35_1}, {2, arcs_35_2}, {1, arcs_35_3}, {1, arcs_35_4}, }; static arc arcs_36_0[8] = { {88, 1}, {89, 1}, {90, 1}, {91, 1}, {92, 1}, {19, 1}, {18, 1}, {17, 1}, }; static arc arcs_36_1[1] = { {0, 1}, }; static state states_36[2] = { {8, arcs_36_0}, {1, arcs_36_1}, }; static arc arcs_37_0[1] = { {93, 1}, }; static arc arcs_37_1[1] = { {29, 2}, }; static arc arcs_37_2[1] = { {23, 3}, }; static arc arcs_37_3[1] = { {25, 4}, }; static arc arcs_37_4[3] = { {94, 1}, {95, 5}, {0, 4}, }; static arc arcs_37_5[1] = { {23, 6}, }; static arc arcs_37_6[1] = { {25, 7}, }; static arc arcs_37_7[1] = { {0, 7}, }; static state states_37[8] = { {1, arcs_37_0}, {1, arcs_37_1}, {1, arcs_37_2}, {1, arcs_37_3}, {3, arcs_37_4}, {1, arcs_37_5}, {1, arcs_37_6}, {1, arcs_37_7}, }; static arc arcs_38_0[1] = { {96, 1}, }; static arc arcs_38_1[1] = { {29, 2}, }; static arc arcs_38_2[1] = { {23, 3}, }; static arc arcs_38_3[1] = { {25, 4}, }; static arc arcs_38_4[2] = { {95, 5}, {0, 4}, }; static arc arcs_38_5[1] = { {23, 6}, }; static arc arcs_38_6[1] = { {25, 7}, }; static arc arcs_38_7[1] = { {0, 7}, }; static state states_38[8] = { {1, arcs_38_0}, {1, arcs_38_1}, {1, arcs_38_2}, {1, arcs_38_3}, {2, arcs_38_4}, {1, arcs_38_5}, {1, arcs_38_6}, {1, arcs_38_7}, }; static arc arcs_39_0[1] = { {97, 1}, }; static arc arcs_39_1[1] = { {62, 2}, }; static arc arcs_39_2[1] = { {86, 3}, }; static arc arcs_39_3[1] = { {9, 4}, }; static arc arcs_39_4[1] = { {23, 5}, }; static arc arcs_39_5[2] = { {24, 6}, {25, 7}, }; static arc arcs_39_6[1] = { {25, 7}, }; static arc arcs_39_7[2] = { {95, 8}, {0, 7}, }; static arc arcs_39_8[1] = { {23, 9}, }; static arc arcs_39_9[1] = { {25, 10}, }; static arc arcs_39_10[1] = { {0, 10}, }; static state states_39[11] = { {1, arcs_39_0}, {1, arcs_39_1}, {1, arcs_39_2}, {1, arcs_39_3}, {1, arcs_39_4}, {2, arcs_39_5}, {1, arcs_39_6}, {2, arcs_39_7}, {1, arcs_39_8}, {1, arcs_39_9}, {1, arcs_39_10}, }; static arc arcs_40_0[1] = { {98, 1}, }; static arc arcs_40_1[1] = { {23, 2}, }; static arc arcs_40_2[1] = { {25, 3}, }; static arc arcs_40_3[2] = { {99, 4}, {100, 5}, }; static arc arcs_40_4[1] = { {23, 6}, }; static arc arcs_40_5[1] = { {23, 7}, }; static arc arcs_40_6[1] = { {25, 8}, }; static arc arcs_40_7[1] = { {25, 9}, }; static arc arcs_40_8[4] = { {99, 4}, {95, 10}, {100, 5}, {0, 8}, }; static arc arcs_40_9[1] = { {0, 9}, }; static arc arcs_40_10[1] = { {23, 11}, }; static arc arcs_40_11[1] = { {25, 12}, }; static arc arcs_40_12[2] = { {100, 5}, {0, 12}, }; static state states_40[13] = { {1, arcs_40_0}, {1, arcs_40_1}, {1, arcs_40_2}, {2, arcs_40_3}, {1, arcs_40_4}, {1, arcs_40_5}, {1, arcs_40_6}, {1, arcs_40_7}, {4, arcs_40_8}, {1, arcs_40_9}, {1, arcs_40_10}, {1, arcs_40_11}, {2, arcs_40_12}, }; static arc arcs_41_0[1] = { {101, 1}, }; static arc arcs_41_1[1] = { {102, 2}, }; static arc arcs_41_2[2] = { {30, 1}, {23, 3}, }; static arc arcs_41_3[2] = { {24, 4}, {25, 5}, }; static arc arcs_41_4[1] = { {25, 5}, }; static arc arcs_41_5[1] = { {0, 5}, }; static state states_41[6] = { {1, arcs_41_0}, {1, arcs_41_1}, {2, arcs_41_2}, {2, arcs_41_3}, {1, arcs_41_4}, {1, arcs_41_5}, }; static arc arcs_42_0[1] = { {29, 1}, }; static arc arcs_42_1[2] = { {81, 2}, {0, 1}, }; static arc arcs_42_2[1] = { {85, 3}, }; static arc arcs_42_3[1] = { {0, 3}, }; static state states_42[4] = { {1, arcs_42_0}, {2, arcs_42_1}, {1, arcs_42_2}, {1, arcs_42_3}, }; static arc arcs_43_0[1] = { {103, 1}, }; static arc arcs_43_1[2] = { {29, 2}, {0, 1}, }; static arc arcs_43_2[3] = { {81, 3}, {30, 3}, {0, 2}, }; static arc arcs_43_3[1] = { {29, 4}, }; static arc arcs_43_4[1] = { {0, 4}, }; static state states_43[5] = { {1, arcs_43_0}, {2, arcs_43_1}, {3, arcs_43_2}, {1, arcs_43_3}, {1, arcs_43_4}, }; static arc arcs_44_0[2] = { {3, 1}, {2, 2}, }; static arc arcs_44_1[1] = { {0, 1}, }; static arc arcs_44_2[2] = { {24, 3}, {104, 4}, }; static arc arcs_44_3[1] = { {2, 5}, }; static arc arcs_44_4[1] = { {6, 6}, }; static arc arcs_44_5[1] = { {104, 4}, }; static arc arcs_44_6[2] = { {6, 6}, {105, 1}, }; static state states_44[7] = { {2, arcs_44_0}, {1, arcs_44_1}, {2, arcs_44_2}, {1, arcs_44_3}, {1, arcs_44_4}, {1, arcs_44_5}, {2, arcs_44_6}, }; static arc arcs_45_0[1] = { {107, 1}, }; static arc arcs_45_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_45_2[1] = { {107, 3}, }; static arc arcs_45_3[2] = { {30, 4}, {0, 3}, }; static arc arcs_45_4[2] = { {107, 3}, {0, 4}, }; static state states_45[5] = { {1, arcs_45_0}, {2, arcs_45_1}, {1, arcs_45_2}, {2, arcs_45_3}, {2, arcs_45_4}, }; static arc arcs_46_0[2] = { {108, 1}, {109, 1}, }; static arc arcs_46_1[1] = { {0, 1}, }; static state states_46[2] = { {2, arcs_46_0}, {1, arcs_46_1}, }; static arc arcs_47_0[1] = { {110, 1}, }; static arc arcs_47_1[2] = { {26, 2}, {23, 3}, }; static arc arcs_47_2[1] = { {23, 3}, }; static arc arcs_47_3[1] = { {107, 4}, }; static arc arcs_47_4[1] = { {0, 4}, }; static state states_47[5] = { {1, arcs_47_0}, {2, arcs_47_1}, {1, arcs_47_2}, {1, arcs_47_3}, {1, arcs_47_4}, }; static arc arcs_48_0[2] = { {108, 1}, {111, 2}, }; static arc arcs_48_1[2] = { {93, 3}, {0, 1}, }; static arc arcs_48_2[1] = { {0, 2}, }; static arc arcs_48_3[1] = { {108, 4}, }; static arc arcs_48_4[1] = { {95, 5}, }; static arc arcs_48_5[1] = { {29, 2}, }; static state states_48[6] = { {2, arcs_48_0}, {2, arcs_48_1}, {1, arcs_48_2}, {1, arcs_48_3}, {1, arcs_48_4}, {1, arcs_48_5}, }; static arc arcs_49_0[1] = { {112, 1}, }; static arc arcs_49_1[2] = { {113, 0}, {0, 1}, }; static state states_49[2] = { {1, arcs_49_0}, {2, arcs_49_1}, }; static arc arcs_50_0[1] = { {114, 1}, }; static arc arcs_50_1[2] = { {115, 0}, {0, 1}, }; static state states_50[2] = { {1, arcs_50_0}, {2, arcs_50_1}, }; static arc arcs_51_0[2] = { {116, 1}, {117, 2}, }; static arc arcs_51_1[1] = { {114, 2}, }; static arc arcs_51_2[1] = { {0, 2}, }; static state states_51[3] = { {2, arcs_51_0}, {1, arcs_51_1}, {1, arcs_51_2}, }; static arc arcs_52_0[1] = { {85, 1}, }; static arc arcs_52_1[2] = { {118, 0}, {0, 1}, }; static state states_52[2] = { {1, arcs_52_0}, {2, arcs_52_1}, }; static arc arcs_53_0[10] = { {119, 1}, {120, 1}, {121, 1}, {122, 1}, {123, 1}, {124, 1}, {125, 1}, {86, 1}, {116, 2}, {126, 3}, }; static arc arcs_53_1[1] = { {0, 1}, }; static arc arcs_53_2[1] = { {86, 1}, }; static arc arcs_53_3[2] = { {116, 1}, {0, 3}, }; static state states_53[4] = { {10, arcs_53_0}, {1, arcs_53_1}, {1, arcs_53_2}, {2, arcs_53_3}, }; static arc arcs_54_0[1] = { {127, 1}, }; static arc arcs_54_1[2] = { {128, 0}, {0, 1}, }; static state states_54[2] = { {1, arcs_54_0}, {2, arcs_54_1}, }; static arc arcs_55_0[1] = { {129, 1}, }; static arc arcs_55_1[2] = { {130, 0}, {0, 1}, }; static state states_55[2] = { {1, arcs_55_0}, {2, arcs_55_1}, }; static arc arcs_56_0[1] = { {131, 1}, }; static arc arcs_56_1[2] = { {132, 0}, {0, 1}, }; static state states_56[2] = { {1, arcs_56_0}, {2, arcs_56_1}, }; static arc arcs_57_0[1] = { {133, 1}, }; static arc arcs_57_1[3] = { {134, 0}, {60, 0}, {0, 1}, }; static state states_57[2] = { {1, arcs_57_0}, {3, arcs_57_1}, }; static arc arcs_58_0[1] = { {135, 1}, }; static arc arcs_58_1[3] = { {136, 0}, {137, 0}, {0, 1}, }; static state states_58[2] = { {1, arcs_58_0}, {3, arcs_58_1}, }; static arc arcs_59_0[1] = { {138, 1}, }; static arc arcs_59_1[5] = { {31, 0}, {139, 0}, {140, 0}, {141, 0}, {0, 1}, }; static state states_59[2] = { {1, arcs_59_0}, {5, arcs_59_1}, }; static arc arcs_60_0[4] = { {136, 1}, {137, 1}, {142, 1}, {143, 2}, }; static arc arcs_60_1[1] = { {138, 2}, }; static arc arcs_60_2[1] = { {0, 2}, }; static state states_60[3] = { {4, arcs_60_0}, {1, arcs_60_1}, {1, arcs_60_2}, }; static arc arcs_61_0[1] = { {144, 1}, }; static arc arcs_61_1[3] = { {145, 1}, {32, 2}, {0, 1}, }; static arc arcs_61_2[1] = { {138, 3}, }; static arc arcs_61_3[1] = { {0, 3}, }; static state states_61[4] = { {1, arcs_61_0}, {3, arcs_61_1}, {1, arcs_61_2}, {1, arcs_61_3}, }; static arc arcs_62_0[7] = { {13, 1}, {147, 2}, {150, 3}, {153, 4}, {21, 5}, {155, 5}, {156, 6}, }; static arc arcs_62_1[3] = { {46, 7}, {146, 7}, {15, 5}, }; static arc arcs_62_2[2] = { {148, 8}, {149, 5}, }; static arc arcs_62_3[2] = { {151, 9}, {152, 5}, }; static arc arcs_62_4[1] = { {154, 10}, }; static arc arcs_62_5[1] = { {0, 5}, }; static arc arcs_62_6[2] = { {156, 6}, {0, 6}, }; static arc arcs_62_7[1] = { {15, 5}, }; static arc arcs_62_8[1] = { {149, 5}, }; static arc arcs_62_9[1] = { {152, 5}, }; static arc arcs_62_10[1] = { {153, 5}, }; static state states_62[11] = { {7, arcs_62_0}, {3, arcs_62_1}, {2, arcs_62_2}, {2, arcs_62_3}, {1, arcs_62_4}, {1, arcs_62_5}, {2, arcs_62_6}, {1, arcs_62_7}, {1, arcs_62_8}, {1, arcs_62_9}, {1, arcs_62_10}, }; static arc arcs_63_0[1] = { {29, 1}, }; static arc arcs_63_1[3] = { {157, 2}, {30, 3}, {0, 1}, }; static arc arcs_63_2[1] = { {0, 2}, }; static arc arcs_63_3[2] = { {29, 4}, {0, 3}, }; static arc arcs_63_4[2] = { {30, 3}, {0, 4}, }; static state states_63[5] = { {1, arcs_63_0}, {3, arcs_63_1}, {1, arcs_63_2}, {2, arcs_63_3}, {2, arcs_63_4}, }; static arc arcs_64_0[1] = { {29, 1}, }; static arc arcs_64_1[3] = { {158, 2}, {30, 3}, {0, 1}, }; static arc arcs_64_2[1] = { {0, 2}, }; static arc arcs_64_3[2] = { {29, 4}, {0, 3}, }; static arc arcs_64_4[2] = { {30, 3}, {0, 4}, }; static state states_64[5] = { {1, arcs_64_0}, {3, arcs_64_1}, {1, arcs_64_2}, {2, arcs_64_3}, {2, arcs_64_4}, }; static arc arcs_65_0[1] = { {110, 1}, }; static arc arcs_65_1[2] = { {26, 2}, {23, 3}, }; static arc arcs_65_2[1] = { {23, 3}, }; static arc arcs_65_3[1] = { {29, 4}, }; static arc arcs_65_4[1] = { {0, 4}, }; static state states_65[5] = { {1, arcs_65_0}, {2, arcs_65_1}, {1, arcs_65_2}, {1, arcs_65_3}, {1, arcs_65_4}, }; static arc arcs_66_0[3] = { {13, 1}, {147, 2}, {78, 3}, }; static arc arcs_66_1[2] = { {14, 4}, {15, 5}, }; static arc arcs_66_2[1] = { {159, 6}, }; static arc arcs_66_3[1] = { {21, 5}, }; static arc arcs_66_4[1] = { {15, 5}, }; static arc arcs_66_5[1] = { {0, 5}, }; static arc arcs_66_6[1] = { {149, 5}, }; static state states_66[7] = { {3, arcs_66_0}, {2, arcs_66_1}, {1, arcs_66_2}, {1, arcs_66_3}, {1, arcs_66_4}, {1, arcs_66_5}, {1, arcs_66_6}, }; static arc arcs_67_0[1] = { {160, 1}, }; static arc arcs_67_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_67_2[2] = { {160, 1}, {0, 2}, }; static state states_67[3] = { {1, arcs_67_0}, {2, arcs_67_1}, {2, arcs_67_2}, }; static arc arcs_68_0[3] = { {78, 1}, {29, 2}, {23, 3}, }; static arc arcs_68_1[1] = { {78, 4}, }; static arc arcs_68_2[2] = { {23, 3}, {0, 2}, }; static arc arcs_68_3[3] = { {29, 5}, {161, 6}, {0, 3}, }; static arc arcs_68_4[1] = { {78, 6}, }; static arc arcs_68_5[2] = { {161, 6}, {0, 5}, }; static arc arcs_68_6[1] = { {0, 6}, }; static state states_68[7] = { {3, arcs_68_0}, {1, arcs_68_1}, {2, arcs_68_2}, {3, arcs_68_3}, {1, arcs_68_4}, {2, arcs_68_5}, {1, arcs_68_6}, }; static arc arcs_69_0[1] = { {23, 1}, }; static arc arcs_69_1[2] = { {29, 2}, {0, 1}, }; static arc arcs_69_2[1] = { {0, 2}, }; static state states_69[3] = { {1, arcs_69_0}, {2, arcs_69_1}, {1, arcs_69_2}, }; static arc arcs_70_0[1] = { {85, 1}, }; static arc arcs_70_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_70_2[2] = { {85, 1}, {0, 2}, }; static state states_70[3] = { {1, arcs_70_0}, {2, arcs_70_1}, {2, arcs_70_2}, }; static arc arcs_71_0[1] = { {29, 1}, }; static arc arcs_71_1[2] = { {30, 2}, {0, 1}, }; static arc arcs_71_2[2] = { {29, 1}, {0, 2}, }; static state states_71[3] = { {1, arcs_71_0}, {2, arcs_71_1}, {2, arcs_71_2}, }; static arc arcs_72_0[1] = { {29, 1}, }; static arc arcs_72_1[4] = { {23, 2}, {158, 3}, {30, 4}, {0, 1}, }; static arc arcs_72_2[1] = { {29, 5}, }; static arc arcs_72_3[1] = { {0, 3}, }; static arc arcs_72_4[2] = { {29, 6}, {0, 4}, }; static arc arcs_72_5[3] = { {158, 3}, {30, 7}, {0, 5}, }; static arc arcs_72_6[2] = { {30, 4}, {0, 6}, }; static arc arcs_72_7[2] = { {29, 8}, {0, 7}, }; static arc arcs_72_8[1] = { {23, 9}, }; static arc arcs_72_9[1] = { {29, 10}, }; static arc arcs_72_10[2] = { {30, 7}, {0, 10}, }; static state states_72[11] = { {1, arcs_72_0}, {4, arcs_72_1}, {1, arcs_72_2}, {1, arcs_72_3}, {2, arcs_72_4}, {3, arcs_72_5}, {2, arcs_72_6}, {2, arcs_72_7}, {1, arcs_72_8}, {1, arcs_72_9}, {2, arcs_72_10}, }; static arc arcs_73_0[1] = { {162, 1}, }; static arc arcs_73_1[1] = { {21, 2}, }; static arc arcs_73_2[2] = { {13, 3}, {23, 4}, }; static arc arcs_73_3[2] = { {9, 5}, {15, 6}, }; static arc arcs_73_4[1] = { {25, 7}, }; static arc arcs_73_5[1] = { {15, 6}, }; static arc arcs_73_6[1] = { {23, 4}, }; static arc arcs_73_7[1] = { {0, 7}, }; static state states_73[8] = { {1, arcs_73_0}, {1, arcs_73_1}, {2, arcs_73_2}, {2, arcs_73_3}, {1, arcs_73_4}, {1, arcs_73_5}, {1, arcs_73_6}, {1, arcs_73_7}, }; static arc arcs_74_0[3] = { {163, 1}, {31, 2}, {32, 3}, }; static arc arcs_74_1[2] = { {30, 4}, {0, 1}, }; static arc arcs_74_2[1] = { {29, 5}, }; static arc arcs_74_3[1] = { {29, 6}, }; static arc arcs_74_4[4] = { {163, 1}, {31, 2}, {32, 3}, {0, 4}, }; static arc arcs_74_5[2] = { {30, 7}, {0, 5}, }; static arc arcs_74_6[1] = { {0, 6}, }; static arc arcs_74_7[2] = { {163, 5}, {32, 3}, }; static state states_74[8] = { {3, arcs_74_0}, {2, arcs_74_1}, {1, arcs_74_2}, {1, arcs_74_3}, {4, arcs_74_4}, {2, arcs_74_5}, {1, arcs_74_6}, {2, arcs_74_7}, }; static arc arcs_75_0[1] = { {29, 1}, }; static arc arcs_75_1[3] = { {158, 2}, {28, 3}, {0, 1}, }; static arc arcs_75_2[1] = { {0, 2}, }; static arc arcs_75_3[1] = { {29, 2}, }; static state states_75[4] = { {1, arcs_75_0}, {3, arcs_75_1}, {1, arcs_75_2}, {1, arcs_75_3}, }; static arc arcs_76_0[2] = { {157, 1}, {165, 1}, }; static arc arcs_76_1[1] = { {0, 1}, }; static state states_76[2] = { {2, arcs_76_0}, {1, arcs_76_1}, }; static arc arcs_77_0[1] = { {97, 1}, }; static arc arcs_77_1[1] = { {62, 2}, }; static arc arcs_77_2[1] = { {86, 3}, }; static arc arcs_77_3[1] = { {106, 4}, }; static arc arcs_77_4[2] = { {164, 5}, {0, 4}, }; static arc arcs_77_5[1] = { {0, 5}, }; static state states_77[6] = { {1, arcs_77_0}, {1, arcs_77_1}, {1, arcs_77_2}, {1, arcs_77_3}, {2, arcs_77_4}, {1, arcs_77_5}, }; static arc arcs_78_0[1] = { {93, 1}, }; static arc arcs_78_1[1] = { {107, 2}, }; static arc arcs_78_2[2] = { {164, 3}, {0, 2}, }; static arc arcs_78_3[1] = { {0, 3}, }; static state states_78[4] = { {1, arcs_78_0}, {1, arcs_78_1}, {2, arcs_78_2}, {1, arcs_78_3}, }; static arc arcs_79_0[2] = { {158, 1}, {167, 1}, }; static arc arcs_79_1[1] = { {0, 1}, }; static state states_79[2] = { {2, arcs_79_0}, {1, arcs_79_1}, }; static arc arcs_80_0[1] = { {97, 1}, }; static arc arcs_80_1[1] = { {62, 2}, }; static arc arcs_80_2[1] = { {86, 3}, }; static arc arcs_80_3[1] = { {108, 4}, }; static arc arcs_80_4[2] = { {166, 5}, {0, 4}, }; static arc arcs_80_5[1] = { {0, 5}, }; static state states_80[6] = { {1, arcs_80_0}, {1, arcs_80_1}, {1, arcs_80_2}, {1, arcs_80_3}, {2, arcs_80_4}, {1, arcs_80_5}, }; static arc arcs_81_0[1] = { {93, 1}, }; static arc arcs_81_1[1] = { {107, 2}, }; static arc arcs_81_2[2] = { {166, 3}, {0, 2}, }; static arc arcs_81_3[1] = { {0, 3}, }; static state states_81[4] = { {1, arcs_81_0}, {1, arcs_81_1}, {2, arcs_81_2}, {1, arcs_81_3}, }; static arc arcs_82_0[1] = { {29, 1}, }; static arc arcs_82_1[2] = { {30, 0}, {0, 1}, }; static state states_82[2] = { {1, arcs_82_0}, {2, arcs_82_1}, }; static arc arcs_83_0[1] = { {21, 1}, }; static arc arcs_83_1[1] = { {0, 1}, }; static state states_83[2] = { {1, arcs_83_0}, {1, arcs_83_1}, }; static arc arcs_84_0[1] = { {169, 1}, }; static arc arcs_84_1[2] = { {9, 2}, {0, 1}, }; static arc arcs_84_2[1] = { {0, 2}, }; static state states_84[3] = { {1, arcs_84_0}, {2, arcs_84_1}, {1, arcs_84_2}, }; static arc arcs_85_0[1] = { {171, 1}, }; static arc arcs_85_1[2] = { {2, 1}, {7, 2}, }; static arc arcs_85_2[1] = { {0, 2}, }; static state states_85[3] = { {1, arcs_85_0}, {2, arcs_85_1}, {1, arcs_85_2}, }; static arc arcs_86_0[1] = { {13, 1}, }; static arc arcs_86_1[2] = { {172, 2}, {15, 3}, }; static arc arcs_86_2[1] = { {15, 3}, }; static arc arcs_86_3[1] = { {173, 4}, }; static arc arcs_86_4[1] = { {29, 5}, }; static arc arcs_86_5[1] = { {0, 5}, }; static state states_86[6] = { {1, arcs_86_0}, {2, arcs_86_1}, {1, arcs_86_2}, {1, arcs_86_3}, {1, arcs_86_4}, {1, arcs_86_5}, }; static arc arcs_87_0[3] = { {29, 1}, {31, 2}, {32, 3}, }; static arc arcs_87_1[2] = { {30, 4}, {0, 1}, }; static arc arcs_87_2[3] = { {29, 5}, {30, 6}, {0, 2}, }; static arc arcs_87_3[1] = { {29, 7}, }; static arc arcs_87_4[4] = { {29, 1}, {31, 8}, {32, 3}, {0, 4}, }; static arc arcs_87_5[2] = { {30, 6}, {0, 5}, }; static arc arcs_87_6[2] = { {29, 5}, {32, 3}, }; static arc arcs_87_7[1] = { {0, 7}, }; static arc arcs_87_8[3] = { {29, 9}, {30, 10}, {0, 8}, }; static arc arcs_87_9[2] = { {30, 10}, {0, 9}, }; static arc arcs_87_10[2] = { {29, 9}, {32, 3}, }; static state states_87[11] = { {3, arcs_87_0}, {2, arcs_87_1}, {3, arcs_87_2}, {1, arcs_87_3}, {4, arcs_87_4}, {2, arcs_87_5}, {2, arcs_87_6}, {1, arcs_87_7}, {3, arcs_87_8}, {2, arcs_87_9}, {2, arcs_87_10}, }; static dfa dfas[88] = { {256, "single_input", 0, 3, states_0, "\004\050\060\000\000\000\000\250\340\051\230\040\047\100\020\000\000\103\110\032\004\002"}, {257, "file_input", 0, 2, states_1, "\204\050\060\000\000\000\000\250\340\051\230\040\047\100\020\000\000\103\110\032\004\002"}, {258, "eval_input", 0, 3, states_2, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {259, "decorator", 0, 7, states_3, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {260, "decorators", 0, 2, states_4, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {261, "decorated", 0, 3, states_5, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {262, "funcdef", 0, 7, states_6, "\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {263, "parameters", 0, 4, states_7, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {264, "varargslist", 0, 13, states_8, "\000\040\040\200\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {265, "fpdef", 0, 4, states_9, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {266, "fplist", 0, 3, states_10, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {267, "stmt", 0, 2, states_11, "\000\050\060\000\000\000\000\250\340\051\230\040\047\100\020\000\000\103\110\032\004\002"}, {268, "simple_stmt", 0, 4, states_12, "\000\040\040\000\000\000\000\250\340\051\230\000\000\100\020\000\000\103\110\032\000\002"}, {269, "small_stmt", 0, 2, states_13, "\000\040\040\000\000\000\000\250\340\051\230\000\000\100\020\000\000\103\110\032\000\002"}, {270, "expr_stmt", 0, 6, states_14, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {271, "augassign", 0, 2, states_15, "\000\000\000\000\000\200\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {272, "print_stmt", 0, 9, states_16, "\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {273, "del_stmt", 0, 3, states_17, "\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {274, "pass_stmt", 0, 2, states_18, "\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {275, "flow_stmt", 0, 2, states_19, "\000\000\000\000\000\000\000\000\340\001\000\000\000\000\000\000\000\000\000\000\000\002"}, {276, "break_stmt", 0, 2, states_20, "\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {277, "continue_stmt", 0, 2, states_21, "\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {278, "return_stmt", 0, 3, states_22, "\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {279, "yield_stmt", 0, 2, states_23, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002"}, {280, "raise_stmt", 0, 7, states_24, "\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000"}, {281, "import_stmt", 0, 2, states_25, "\000\000\000\000\000\000\000\000\000\050\000\000\000\000\000\000\000\000\000\000\000\000"}, {282, "import_name", 0, 3, states_26, "\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000"}, {283, "import_from", 0, 8, states_27, "\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000"}, {284, "import_as_name", 0, 4, states_28, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {285, "dotted_as_name", 0, 4, states_29, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {286, "import_as_names", 0, 3, states_30, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {287, "dotted_as_names", 0, 2, states_31, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {288, "dotted_name", 0, 2, states_32, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {289, "global_stmt", 0, 3, states_33, "\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000"}, {290, "exec_stmt", 0, 7, states_34, "\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000"}, {291, "assert_stmt", 0, 5, states_35, "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000"}, {292, "compound_stmt", 0, 2, states_36, "\000\010\020\000\000\000\000\000\000\000\000\040\047\000\000\000\000\000\000\000\004\000"}, {293, "if_stmt", 0, 8, states_37, "\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000"}, {294, "while_stmt", 0, 8, states_38, "\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000"}, {295, "for_stmt", 0, 11, states_39, "\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"}, {296, "try_stmt", 0, 13, states_40, "\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000"}, {297, "with_stmt", 0, 6, states_41, "\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000"}, {298, "with_item", 0, 4, states_42, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {299, "except_clause", 0, 5, states_43, "\000\000\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000"}, {300, "suite", 0, 7, states_44, "\004\040\040\000\000\000\000\250\340\051\230\000\000\100\020\000\000\103\110\032\000\002"}, {301, "testlist_safe", 0, 5, states_45, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {302, "old_test", 0, 2, states_46, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {303, "old_lambdef", 0, 5, states_47, "\000\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000"}, {304, "test", 0, 6, states_48, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {305, "or_test", 0, 2, states_49, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\020\000\000\103\110\032\000\000"}, {306, "and_test", 0, 2, states_50, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\020\000\000\103\110\032\000\000"}, {307, "not_test", 0, 3, states_51, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\020\000\000\103\110\032\000\000"}, {308, "comparison", 0, 2, states_52, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {309, "comp_op", 0, 4, states_53, "\000\000\000\000\000\000\000\000\000\000\100\000\000\000\220\177\000\000\000\000\000\000"}, {310, "expr", 0, 2, states_54, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {311, "xor_expr", 0, 2, states_55, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {312, "and_expr", 0, 2, states_56, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {313, "shift_expr", 0, 2, states_57, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {314, "arith_expr", 0, 2, states_58, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {315, "term", 0, 2, states_59, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {316, "factor", 0, 3, states_60, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {317, "power", 0, 4, states_61, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\110\032\000\000"}, {318, "atom", 0, 11, states_62, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\110\032\000\000"}, {319, "listmaker", 0, 5, states_63, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {320, "testlist_comp", 0, 5, states_64, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {321, "lambdef", 0, 5, states_65, "\000\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000"}, {322, "trailer", 0, 7, states_66, "\000\040\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\010\000\000\000"}, {323, "subscriptlist", 0, 3, states_67, "\000\040\240\000\000\000\000\000\000\100\000\000\000\100\020\000\000\103\110\032\000\000"}, {324, "subscript", 0, 7, states_68, "\000\040\240\000\000\000\000\000\000\100\000\000\000\100\020\000\000\103\110\032\000\000"}, {325, "sliceop", 0, 3, states_69, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {326, "exprlist", 0, 3, states_70, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\103\110\032\000\000"}, {327, "testlist", 0, 3, states_71, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {328, "dictorsetmaker", 0, 11, states_72, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {329, "classdef", 0, 8, states_73, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000"}, {330, "arglist", 0, 8, states_74, "\000\040\040\200\001\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {331, "argument", 0, 4, states_75, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {332, "list_iter", 0, 2, states_76, "\000\000\000\000\000\000\000\000\000\000\000\040\002\000\000\000\000\000\000\000\000\000"}, {333, "list_for", 0, 6, states_77, "\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"}, {334, "list_if", 0, 4, states_78, "\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000"}, {335, "comp_iter", 0, 2, states_79, "\000\000\000\000\000\000\000\000\000\000\000\040\002\000\000\000\000\000\000\000\000\000"}, {336, "comp_for", 0, 6, states_80, "\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"}, {337, "comp_if", 0, 4, states_81, "\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000"}, {338, "testlist1", 0, 2, states_82, "\000\040\040\000\000\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, {339, "encoding_decl", 0, 2, states_83, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {340, "yield_expr", 0, 3, states_84, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002"}, {341, "func_type_input", 0, 3, states_85, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {342, "func_type", 0, 6, states_86, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {343, "typelist", 0, 11, states_87, "\000\040\040\200\001\000\000\000\000\000\000\000\000\100\020\000\000\103\110\032\000\000"}, }; static label labels[174] = { {0, "EMPTY"}, {256, 0}, {4, 0}, {268, 0}, {292, 0}, {257, 0}, {267, 0}, {0, 0}, {258, 0}, {327, 0}, {259, 0}, {50, 0}, {288, 0}, {7, 0}, {330, 0}, {8, 0}, {260, 0}, {261, 0}, {329, 0}, {262, 0}, {1, "def"}, {1, 0}, {263, 0}, {11, 0}, {54, 0}, {300, 0}, {264, 0}, {265, 0}, {22, 0}, {304, 0}, {12, 0}, {16, 0}, {36, 0}, {266, 0}, {269, 0}, {13, 0}, {270, 0}, {272, 0}, {273, 0}, {274, 0}, {275, 0}, {281, 0}, {289, 0}, {290, 0}, {291, 0}, {271, 0}, {340, 0}, {37, 0}, {38, 0}, {39, 0}, {40, 0}, {41, 0}, {42, 0}, {43, 0}, {44, 0}, {45, 0}, {46, 0}, {47, 0}, {49, 0}, {1, "print"}, {35, 0}, {1, "del"}, {326, 0}, {1, "pass"}, {276, 0}, {277, 0}, {278, 0}, {280, 0}, {279, 0}, {1, "break"}, {1, "continue"}, {1, "return"}, {1, "raise"}, {282, 0}, {283, 0}, {1, "import"}, {287, 0}, {1, "from"}, {23, 0}, {286, 0}, {284, 0}, {1, "as"}, {285, 0}, {1, "global"}, {1, "exec"}, {310, 0}, {1, "in"}, {1, "assert"}, {293, 0}, {294, 0}, {295, 0}, {296, 0}, {297, 0}, {1, "if"}, {1, "elif"}, {1, "else"}, {1, "while"}, {1, "for"}, {1, "try"}, {299, 0}, {1, "finally"}, {1, "with"}, {298, 0}, {1, "except"}, {5, 0}, {6, 0}, {301, 0}, {302, 0}, {305, 0}, {303, 0}, {1, "lambda"}, {321, 0}, {306, 0}, {1, "or"}, {307, 0}, {1, "and"}, {1, "not"}, {308, 0}, {309, 0}, {20, 0}, {21, 0}, {28, 0}, {31, 0}, {30, 0}, {29, 0}, {29, 0}, {1, "is"}, {311, 0}, {18, 0}, {312, 0}, {33, 0}, {313, 0}, {19, 0}, {314, 0}, {34, 0}, {315, 0}, {14, 0}, {15, 0}, {316, 0}, {17, 0}, {24, 0}, {48, 0}, {32, 0}, {317, 0}, {318, 0}, {322, 0}, {320, 0}, {9, 0}, {319, 0}, {10, 0}, {26, 0}, {328, 0}, {27, 0}, {25, 0}, {338, 0}, {2, 0}, {3, 0}, {333, 0}, {336, 0}, {323, 0}, {324, 0}, {325, 0}, {1, "class"}, {331, 0}, {332, 0}, {334, 0}, {335, 0}, {337, 0}, {339, 0}, {1, "yield"}, {341, 0}, {342, 0}, {343, 0}, {52, 0}, }; grammar _Ta27Parser_Grammar = { 88, dfas, {174, labels}, 256 }; typed-ast-1.1.0/ast27/Python/mystrtoul.c0000644€Tøžæ€2›s®0000001764213050216645021403 0ustar ddfisher00000000000000 #include "Python.h" #if defined(__sgi) && defined(WITH_THREAD) && !defined(_SGI_MP_SOURCE) #define _SGI_MP_SOURCE #endif /* strtol and strtoul, renamed to avoid conflicts */ #include #ifdef HAVE_ERRNO_H #include #endif /* Static overflow check values for bases 2 through 36. * smallmax[base] is the largest unsigned long i such that * i * base doesn't overflow unsigned long. */ static unsigned long smallmax[] = { 0, /* bases 0 and 1 are invalid */ 0, ULONG_MAX / 2, ULONG_MAX / 3, ULONG_MAX / 4, ULONG_MAX / 5, ULONG_MAX / 6, ULONG_MAX / 7, ULONG_MAX / 8, ULONG_MAX / 9, ULONG_MAX / 10, ULONG_MAX / 11, ULONG_MAX / 12, ULONG_MAX / 13, ULONG_MAX / 14, ULONG_MAX / 15, ULONG_MAX / 16, ULONG_MAX / 17, ULONG_MAX / 18, ULONG_MAX / 19, ULONG_MAX / 20, ULONG_MAX / 21, ULONG_MAX / 22, ULONG_MAX / 23, ULONG_MAX / 24, ULONG_MAX / 25, ULONG_MAX / 26, ULONG_MAX / 27, ULONG_MAX / 28, ULONG_MAX / 29, ULONG_MAX / 30, ULONG_MAX / 31, ULONG_MAX / 32, ULONG_MAX / 33, ULONG_MAX / 34, ULONG_MAX / 35, ULONG_MAX / 36, }; /* maximum digits that can't ever overflow for bases 2 through 36, * calculated by [int(math.floor(math.log(2**32, i))) for i in range(2, 37)]. * Note that this is pessimistic if sizeof(long) > 4. */ #if SIZEOF_LONG == 4 static int digitlimit[] = { 0, 0, 32, 20, 16, 13, 12, 11, 10, 10, /* 0 - 9 */ 9, 9, 8, 8, 8, 8, 8, 7, 7, 7, /* 10 - 19 */ 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, /* 20 - 29 */ 6, 6, 6, 6, 6, 6, 6}; /* 30 - 36 */ #elif SIZEOF_LONG == 8 /* [int(math.floor(math.log(2**64, i))) for i in range(2, 37)] */ static int digitlimit[] = { 0, 0, 64, 40, 32, 27, 24, 22, 21, 20, /* 0 - 9 */ 19, 18, 17, 17, 16, 16, 16, 15, 15, 15, /* 10 - 19 */ 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, /* 20 - 29 */ 13, 12, 12, 12, 12, 12, 12}; /* 30 - 36 */ #else #error "Need table for SIZEOF_LONG" #endif /* ** strtoul ** This is a general purpose routine for converting ** an ascii string to an integer in an arbitrary base. ** Leading white space is ignored. If 'base' is zero ** it looks for a leading 0, 0b, 0B, 0o, 0O, 0x or 0X ** to tell which base. If these are absent it defaults ** to 10. Base must be 0 or between 2 and 36 (inclusive). ** If 'ptr' is non-NULL it will contain a pointer to ** the end of the scan. ** Errors due to bad pointers will probably result in ** exceptions - we don't check for them. */ unsigned long Ta27OS_strtoul(register char *str, char **ptr, int base) { register unsigned long result = 0; /* return value of the function */ register int c; /* current input character */ register int ovlimit; /* required digits to overflow */ /* skip leading white space */ while (*str && isspace(Py_CHARMASK(*str))) ++str; /* check for leading 0 or 0x for auto-base or base 16 */ switch (base) { case 0: /* look for leading 0, 0b, 0o or 0x */ if (*str == '0') { ++str; if (*str == 'x' || *str == 'X') { /* there must be at least one digit after 0x */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) { if (ptr) *ptr = str; return 0; } ++str; base = 16; } else if (*str == 'o' || *str == 'O') { /* there must be at least one digit after 0o */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) { if (ptr) *ptr = str; return 0; } ++str; base = 8; } else if (*str == 'b' || *str == 'B') { /* there must be at least one digit after 0b */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) { if (ptr) *ptr = str; return 0; } ++str; base = 2; } else { base = 8; } } else base = 10; break; case 2: /* skip leading 0b or 0B */ if (*str == '0') { ++str; if (*str == 'b' || *str == 'B') { /* there must be at least one digit after 0b */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) { if (ptr) *ptr = str; return 0; } ++str; } } break; case 8: /* skip leading 0o or 0O */ if (*str == '0') { ++str; if (*str == 'o' || *str == 'O') { /* there must be at least one digit after 0o */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) { if (ptr) *ptr = str; return 0; } ++str; } } break; case 16: /* skip leading 0x or 0X */ if (*str == '0') { ++str; if (*str == 'x' || *str == 'X') { /* there must be at least one digit after 0x */ if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) { if (ptr) *ptr = str; return 0; } ++str; } } break; } /* catch silly bases */ if (base < 2 || base > 36) { if (ptr) *ptr = str; return 0; } /* skip leading zeroes */ while (*str == '0') ++str; /* base is guaranteed to be in [2, 36] at this point */ ovlimit = digitlimit[base]; /* do the conversion until non-digit character encountered */ while ((c = _PyLong_DigitValue[Py_CHARMASK(*str)]) < base) { if (ovlimit > 0) /* no overflow check required */ result = result * base + c; else { /* requires overflow check */ register unsigned long temp_result; if (ovlimit < 0) /* guaranteed overflow */ goto overflowed; /* there could be an overflow */ /* check overflow just from shifting */ if (result > smallmax[base]) goto overflowed; result *= base; /* check overflow from the digit's value */ temp_result = result + c; if (temp_result < result) goto overflowed; result = temp_result; } ++str; --ovlimit; } /* set pointer to point to the last character scanned */ if (ptr) *ptr = str; return result; overflowed: if (ptr) { /* spool through remaining digit characters */ while (_PyLong_DigitValue[Py_CHARMASK(*str)] < base) ++str; *ptr = str; } errno = ERANGE; return (unsigned long)-1; } /* Checking for overflow in PyOS_strtol is a PITA; see comments * about PY_ABS_LONG_MIN in longobject.c. */ #define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN) long Ta27OS_strtol(char *str, char **ptr, int base) { long result; unsigned long uresult; char sign; while (*str && isspace(Py_CHARMASK(*str))) str++; sign = *str; if (sign == '+' || sign == '-') str++; uresult = Ta27OS_strtoul(str, ptr, base); if (uresult <= (unsigned long)LONG_MAX) { result = (long)uresult; if (sign == '-') result = -result; } else if (sign == '-' && uresult == PY_ABS_LONG_MIN) { result = LONG_MIN; } else { errno = ERANGE; result = LONG_MAX; } return result; } typed-ast-1.1.0/ast27/Python/Python-ast.c0000644€Tøžæ€2›s®0000104063113050216645021362 0ustar ddfisher00000000000000/* File automatically generated by Parser/asdl_c.py. */ /* __version__ 82160. This module must be committed separately after each AST grammar change; The __version__ number is set to the revision number of the commit containing the grammar change. */ #include "Python.h" #include "Python-ast.h" static PyTypeObject AST_type; static PyTypeObject *mod_type; static PyObject* ast2obj_mod(void*); static PyTypeObject *Module_type; static char *Module_fields[]={ "body", "type_ignores", }; static PyTypeObject *Interactive_type; static char *Interactive_fields[]={ "body", }; static PyTypeObject *Expression_type; static char *Expression_fields[]={ "body", }; static PyTypeObject *FunctionType_type; static char *FunctionType_fields[]={ "argtypes", "returns", }; static PyTypeObject *Suite_type; static char *Suite_fields[]={ "body", }; static PyTypeObject *stmt_type; static char *stmt_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_stmt(void*); static PyTypeObject *FunctionDef_type; static char *FunctionDef_fields[]={ "name", "args", "body", "decorator_list", "type_comment", }; static PyTypeObject *ClassDef_type; static char *ClassDef_fields[]={ "name", "bases", "body", "decorator_list", }; static PyTypeObject *Return_type; static char *Return_fields[]={ "value", }; static PyTypeObject *Delete_type; static char *Delete_fields[]={ "targets", }; static PyTypeObject *Assign_type; static char *Assign_fields[]={ "targets", "value", "type_comment", }; static PyTypeObject *AugAssign_type; static char *AugAssign_fields[]={ "target", "op", "value", }; static PyTypeObject *Print_type; static char *Print_fields[]={ "dest", "values", "nl", }; static PyTypeObject *For_type; static char *For_fields[]={ "target", "iter", "body", "orelse", "type_comment", }; static PyTypeObject *While_type; static char *While_fields[]={ "test", "body", "orelse", }; static PyTypeObject *If_type; static char *If_fields[]={ "test", "body", "orelse", }; static PyTypeObject *With_type; static char *With_fields[]={ "context_expr", "optional_vars", "body", "type_comment", }; static PyTypeObject *Raise_type; static char *Raise_fields[]={ "type", "inst", "tback", }; static PyTypeObject *TryExcept_type; static char *TryExcept_fields[]={ "body", "handlers", "orelse", }; static PyTypeObject *TryFinally_type; static char *TryFinally_fields[]={ "body", "finalbody", }; static PyTypeObject *Assert_type; static char *Assert_fields[]={ "test", "msg", }; static PyTypeObject *Import_type; static char *Import_fields[]={ "names", }; static PyTypeObject *ImportFrom_type; static char *ImportFrom_fields[]={ "module", "names", "level", }; static PyTypeObject *Exec_type; static char *Exec_fields[]={ "body", "globals", "locals", }; static PyTypeObject *Global_type; static char *Global_fields[]={ "names", }; static PyTypeObject *Expr_type; static char *Expr_fields[]={ "value", }; static PyTypeObject *Pass_type; static PyTypeObject *Break_type; static PyTypeObject *Continue_type; static PyTypeObject *expr_type; static char *expr_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_expr(void*); static PyTypeObject *BoolOp_type; static char *BoolOp_fields[]={ "op", "values", }; static PyTypeObject *BinOp_type; static char *BinOp_fields[]={ "left", "op", "right", }; static PyTypeObject *UnaryOp_type; static char *UnaryOp_fields[]={ "op", "operand", }; static PyTypeObject *Lambda_type; static char *Lambda_fields[]={ "args", "body", }; static PyTypeObject *IfExp_type; static char *IfExp_fields[]={ "test", "body", "orelse", }; static PyTypeObject *Dict_type; static char *Dict_fields[]={ "keys", "values", }; static PyTypeObject *Set_type; static char *Set_fields[]={ "elts", }; static PyTypeObject *ListComp_type; static char *ListComp_fields[]={ "elt", "generators", }; static PyTypeObject *SetComp_type; static char *SetComp_fields[]={ "elt", "generators", }; static PyTypeObject *DictComp_type; static char *DictComp_fields[]={ "key", "value", "generators", }; static PyTypeObject *GeneratorExp_type; static char *GeneratorExp_fields[]={ "elt", "generators", }; static PyTypeObject *Yield_type; static char *Yield_fields[]={ "value", }; static PyTypeObject *Compare_type; static char *Compare_fields[]={ "left", "ops", "comparators", }; static PyTypeObject *Call_type; static char *Call_fields[]={ "func", "args", "keywords", "starargs", "kwargs", }; static PyTypeObject *Repr_type; static char *Repr_fields[]={ "value", }; static PyTypeObject *Num_type; static char *Num_fields[]={ "n", }; static PyTypeObject *Str_type; static char *Str_fields[]={ "s", "has_b", }; static PyTypeObject *Attribute_type; static char *Attribute_fields[]={ "value", "attr", "ctx", }; static PyTypeObject *Subscript_type; static char *Subscript_fields[]={ "value", "slice", "ctx", }; static PyTypeObject *Name_type; static char *Name_fields[]={ "id", "ctx", }; static PyTypeObject *List_type; static char *List_fields[]={ "elts", "ctx", }; static PyTypeObject *Tuple_type; static char *Tuple_fields[]={ "elts", "ctx", }; static PyTypeObject *expr_context_type; static PyObject *Load_singleton, *Store_singleton, *Del_singleton, *AugLoad_singleton, *AugStore_singleton, *Param_singleton; static PyObject* ast2obj_expr_context(expr_context_ty); static PyTypeObject *Load_type; static PyTypeObject *Store_type; static PyTypeObject *Del_type; static PyTypeObject *AugLoad_type; static PyTypeObject *AugStore_type; static PyTypeObject *Param_type; static PyTypeObject *slice_type; static PyObject* ast2obj_slice(void*); static PyTypeObject *Ellipsis_type; static PyTypeObject *Slice_type; static char *Slice_fields[]={ "lower", "upper", "step", }; static PyTypeObject *ExtSlice_type; static char *ExtSlice_fields[]={ "dims", }; static PyTypeObject *Index_type; static char *Index_fields[]={ "value", }; static PyTypeObject *boolop_type; static PyObject *And_singleton, *Or_singleton; static PyObject* ast2obj_boolop(boolop_ty); static PyTypeObject *And_type; static PyTypeObject *Or_type; static PyTypeObject *operator_type; static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton, *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton, *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton, *FloorDiv_singleton; static PyObject* ast2obj_operator(operator_ty); static PyTypeObject *Add_type; static PyTypeObject *Sub_type; static PyTypeObject *Mult_type; static PyTypeObject *Div_type; static PyTypeObject *Mod_type; static PyTypeObject *Pow_type; static PyTypeObject *LShift_type; static PyTypeObject *RShift_type; static PyTypeObject *BitOr_type; static PyTypeObject *BitXor_type; static PyTypeObject *BitAnd_type; static PyTypeObject *FloorDiv_type; static PyTypeObject *unaryop_type; static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton, *USub_singleton; static PyObject* ast2obj_unaryop(unaryop_ty); static PyTypeObject *Invert_type; static PyTypeObject *Not_type; static PyTypeObject *UAdd_type; static PyTypeObject *USub_type; static PyTypeObject *cmpop_type; static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton, *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton, *NotIn_singleton; static PyObject* ast2obj_cmpop(cmpop_ty); static PyTypeObject *Eq_type; static PyTypeObject *NotEq_type; static PyTypeObject *Lt_type; static PyTypeObject *LtE_type; static PyTypeObject *Gt_type; static PyTypeObject *GtE_type; static PyTypeObject *Is_type; static PyTypeObject *IsNot_type; static PyTypeObject *In_type; static PyTypeObject *NotIn_type; static PyTypeObject *comprehension_type; static PyObject* ast2obj_comprehension(void*); static char *comprehension_fields[]={ "target", "iter", "ifs", }; static PyTypeObject *excepthandler_type; static char *excepthandler_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_excepthandler(void*); static PyTypeObject *ExceptHandler_type; static char *ExceptHandler_fields[]={ "type", "name", "body", }; static PyTypeObject *arguments_type; static PyObject* ast2obj_arguments(void*); static char *arguments_fields[]={ "args", "vararg", "kwarg", "defaults", "type_comments", }; static PyTypeObject *keyword_type; static PyObject* ast2obj_keyword(void*); static char *keyword_fields[]={ "arg", "value", }; static PyTypeObject *alias_type; static PyObject* ast2obj_alias(void*); static char *alias_fields[]={ "name", "asname", }; static PyTypeObject *type_ignore_type; static PyObject* ast2obj_type_ignore(void*); static PyTypeObject *TypeIgnore_type; static char *TypeIgnore_fields[]={ "lineno", }; static int ast_type_init(PyObject *self, PyObject *args, PyObject *kw) { Py_ssize_t i, numfields = 0; int res = -1; PyObject *key, *value, *fields; fields = PyObject_GetAttrString((PyObject*)Py_TYPE(self), "_fields"); if (!fields) PyErr_Clear(); if (fields) { numfields = PySequence_Size(fields); if (numfields == -1) goto cleanup; } res = 0; /* if no error occurs, this stays 0 to the end */ if (PyTuple_GET_SIZE(args) > 0) { if (numfields != PyTuple_GET_SIZE(args)) { PyErr_Format(PyExc_TypeError, "%.400s constructor takes %s" "%zd positional argument%s", Py_TYPE(self)->tp_name, numfields == 0 ? "" : "either 0 or ", numfields, numfields == 1 ? "" : "s"); res = -1; goto cleanup; } for (i = 0; i < PyTuple_GET_SIZE(args); i++) { /* cannot be reached when fields is NULL */ PyObject *name = PySequence_GetItem(fields, i); if (!name) { res = -1; goto cleanup; } res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i)); Py_DECREF(name); if (res < 0) goto cleanup; } } if (kw) { i = 0; /* needed by PyDict_Next */ while (PyDict_Next(kw, &i, &key, &value)) { res = PyObject_SetAttr(self, key, value); if (res < 0) goto cleanup; } } cleanup: Py_XDECREF(fields); return res; } /* Pickling support */ static PyObject * ast_type_reduce(PyObject *self, PyObject *unused) { PyObject *res; PyObject *dict = PyObject_GetAttrString(self, "__dict__"); if (dict == NULL) { if (PyErr_ExceptionMatches(PyExc_AttributeError)) PyErr_Clear(); else return NULL; } if (dict) { res = Py_BuildValue("O()O", Py_TYPE(self), dict); Py_DECREF(dict); return res; } return Py_BuildValue("O()", Py_TYPE(self)); } static PyMethodDef ast_type_methods[] = { {"__reduce__", ast_type_reduce, METH_NOARGS, NULL}, {NULL} }; static PyTypeObject AST_type = { PyVarObject_HEAD_INIT(NULL, 0) "_ast27.AST", sizeof(PyObject), 0, 0, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ PyObject_GenericSetAttr, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ ast_type_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc)ast_type_init, /* tp_init */ PyType_GenericAlloc, /* tp_alloc */ PyType_GenericNew, /* tp_new */ PyObject_Del, /* tp_free */ }; static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields) { PyObject *fnames, *result; int i; fnames = PyTuple_New(num_fields); if (!fnames) return NULL; for (i = 0; i < num_fields; i++) { PyObject *field = PyUnicode_FromString(fields[i]); if (!field) { Py_DECREF(fnames); return NULL; } PyTuple_SET_ITEM(fnames, i, field); } result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}", type, base, "_fields", fnames, "__module__", "_ast27"); Py_DECREF(fnames); return (PyTypeObject*)result; } static int add_attributes(PyTypeObject* type, char**attrs, int num_fields) { int i, result; PyObject *s, *l = PyTuple_New(num_fields); if (!l) return 0; for (i = 0; i < num_fields; i++) { s = PyUnicode_FromString(attrs[i]); if (!s) { Py_DECREF(l); return 0; } PyTuple_SET_ITEM(l, i, s); } result = PyObject_SetAttrString((PyObject*)type, "_attributes", l) >= 0; Py_DECREF(l); return result; } /* Conversion AST -> Python */ static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*)) { int i, n = asdl_seq_LEN(seq); PyObject *result = PyList_New(n); PyObject *value; if (!result) return NULL; for (i = 0; i < n; i++) { value = func(asdl_seq_GET(seq, i)); if (!value) { Py_DECREF(result); return NULL; } PyList_SET_ITEM(result, i, value); } return result; } static PyObject* ast2obj_object(void *o) { if (!o) o = Py_None; Py_INCREF((PyObject*)o); return (PyObject*)o; } #define ast2obj_identifier ast2obj_object #define ast2obj_string ast2obj_object static PyObject* ast2obj_bool(bool b) { return PyBool_FromLong(b); } static PyObject* ast2obj_int(long b) { return PyLong_FromLong(b); } /* Conversion Python -> AST */ static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena) { if (obj == Py_None) obj = NULL; if (obj) PyArena_AddPyObject(arena, obj); Py_XINCREF(obj); *out = obj; return 0; } static int obj2ast_identifier(PyObject* obj, PyObject** out, PyArena* arena) { if (!PyUnicode_CheckExact(obj) && obj != Py_None) { PyErr_Format(PyExc_TypeError, "AST identifier must be of type str"); return 1; } return obj2ast_object(obj, out, arena); } static int obj2ast_string(PyObject* obj, PyObject** out, PyArena* arena) { if (!PyUnicode_CheckExact(obj) && !PyUnicode_CheckExact(obj)) { PyErr_SetString(PyExc_TypeError, "AST string must be of type str or unicode"); return 1; } return obj2ast_object(obj, out, arena); } static int obj2ast_int(PyObject* obj, int* out, PyArena* arena) { int i; if (!PyLong_Check(obj) && !PyLong_Check(obj)) { PyObject *s = PyObject_Repr(obj); if (s == NULL) return 1; PyErr_Format(PyExc_ValueError, "invalid integer value: %.400s", _PyUnicode_AsString(s)); Py_DECREF(s); return 1; } i = (int)PyLong_AsLong(obj); if (i == -1 && PyErr_Occurred()) return 1; *out = i; return 0; } static int obj2ast_bool(PyObject* obj, bool* out, PyArena* arena) { if (!PyBool_Check(obj)) { PyObject *s = PyObject_Repr(obj); if (s == NULL) return 1; PyErr_Format(PyExc_ValueError, "invalid boolean value: %.400s", _PyUnicode_AsString(s)); Py_DECREF(s); return 1; } *out = (obj == Py_True); return 0; } static int add_ast_fields(void) { PyObject *empty_tuple, *d; if (PyType_Ready(&AST_type) < 0) return -1; d = AST_type.tp_dict; empty_tuple = PyTuple_New(0); if (!empty_tuple || PyDict_SetItemString(d, "_fields", empty_tuple) < 0 || PyDict_SetItemString(d, "_attributes", empty_tuple) < 0) { Py_XDECREF(empty_tuple); return -1; } Py_DECREF(empty_tuple); return 0; } static int init_types(void) { static int initialized; if (initialized) return 1; if (add_ast_fields() < 0) return 0; mod_type = make_type("mod", &AST_type, NULL, 0); if (!mod_type) return 0; if (!add_attributes(mod_type, NULL, 0)) return 0; Module_type = make_type("Module", mod_type, Module_fields, 2); if (!Module_type) return 0; Interactive_type = make_type("Interactive", mod_type, Interactive_fields, 1); if (!Interactive_type) return 0; Expression_type = make_type("Expression", mod_type, Expression_fields, 1); if (!Expression_type) return 0; FunctionType_type = make_type("FunctionType", mod_type, FunctionType_fields, 2); if (!FunctionType_type) return 0; Suite_type = make_type("Suite", mod_type, Suite_fields, 1); if (!Suite_type) return 0; stmt_type = make_type("stmt", &AST_type, NULL, 0); if (!stmt_type) return 0; if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0; FunctionDef_type = make_type("FunctionDef", stmt_type, FunctionDef_fields, 5); if (!FunctionDef_type) return 0; ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 4); if (!ClassDef_type) return 0; Return_type = make_type("Return", stmt_type, Return_fields, 1); if (!Return_type) return 0; Delete_type = make_type("Delete", stmt_type, Delete_fields, 1); if (!Delete_type) return 0; Assign_type = make_type("Assign", stmt_type, Assign_fields, 3); if (!Assign_type) return 0; AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3); if (!AugAssign_type) return 0; Print_type = make_type("Print", stmt_type, Print_fields, 3); if (!Print_type) return 0; For_type = make_type("For", stmt_type, For_fields, 5); if (!For_type) return 0; While_type = make_type("While", stmt_type, While_fields, 3); if (!While_type) return 0; If_type = make_type("If", stmt_type, If_fields, 3); if (!If_type) return 0; With_type = make_type("With", stmt_type, With_fields, 4); if (!With_type) return 0; Raise_type = make_type("Raise", stmt_type, Raise_fields, 3); if (!Raise_type) return 0; TryExcept_type = make_type("TryExcept", stmt_type, TryExcept_fields, 3); if (!TryExcept_type) return 0; TryFinally_type = make_type("TryFinally", stmt_type, TryFinally_fields, 2); if (!TryFinally_type) return 0; Assert_type = make_type("Assert", stmt_type, Assert_fields, 2); if (!Assert_type) return 0; Import_type = make_type("Import", stmt_type, Import_fields, 1); if (!Import_type) return 0; ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields, 3); if (!ImportFrom_type) return 0; Exec_type = make_type("Exec", stmt_type, Exec_fields, 3); if (!Exec_type) return 0; Global_type = make_type("Global", stmt_type, Global_fields, 1); if (!Global_type) return 0; Expr_type = make_type("Expr", stmt_type, Expr_fields, 1); if (!Expr_type) return 0; Pass_type = make_type("Pass", stmt_type, NULL, 0); if (!Pass_type) return 0; Break_type = make_type("Break", stmt_type, NULL, 0); if (!Break_type) return 0; Continue_type = make_type("Continue", stmt_type, NULL, 0); if (!Continue_type) return 0; expr_type = make_type("expr", &AST_type, NULL, 0); if (!expr_type) return 0; if (!add_attributes(expr_type, expr_attributes, 2)) return 0; BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2); if (!BoolOp_type) return 0; BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3); if (!BinOp_type) return 0; UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2); if (!UnaryOp_type) return 0; Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2); if (!Lambda_type) return 0; IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3); if (!IfExp_type) return 0; Dict_type = make_type("Dict", expr_type, Dict_fields, 2); if (!Dict_type) return 0; Set_type = make_type("Set", expr_type, Set_fields, 1); if (!Set_type) return 0; ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2); if (!ListComp_type) return 0; SetComp_type = make_type("SetComp", expr_type, SetComp_fields, 2); if (!SetComp_type) return 0; DictComp_type = make_type("DictComp", expr_type, DictComp_fields, 3); if (!DictComp_type) return 0; GeneratorExp_type = make_type("GeneratorExp", expr_type, GeneratorExp_fields, 2); if (!GeneratorExp_type) return 0; Yield_type = make_type("Yield", expr_type, Yield_fields, 1); if (!Yield_type) return 0; Compare_type = make_type("Compare", expr_type, Compare_fields, 3); if (!Compare_type) return 0; Call_type = make_type("Call", expr_type, Call_fields, 5); if (!Call_type) return 0; Repr_type = make_type("Repr", expr_type, Repr_fields, 1); if (!Repr_type) return 0; Num_type = make_type("Num", expr_type, Num_fields, 1); if (!Num_type) return 0; Str_type = make_type("Str", expr_type, Str_fields, 2); if (!Str_type) return 0; Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3); if (!Attribute_type) return 0; Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3); if (!Subscript_type) return 0; Name_type = make_type("Name", expr_type, Name_fields, 2); if (!Name_type) return 0; List_type = make_type("List", expr_type, List_fields, 2); if (!List_type) return 0; Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2); if (!Tuple_type) return 0; expr_context_type = make_type("expr_context", &AST_type, NULL, 0); if (!expr_context_type) return 0; if (!add_attributes(expr_context_type, NULL, 0)) return 0; Load_type = make_type("Load", expr_context_type, NULL, 0); if (!Load_type) return 0; Load_singleton = PyType_GenericNew(Load_type, NULL, NULL); if (!Load_singleton) return 0; Store_type = make_type("Store", expr_context_type, NULL, 0); if (!Store_type) return 0; Store_singleton = PyType_GenericNew(Store_type, NULL, NULL); if (!Store_singleton) return 0; Del_type = make_type("Del", expr_context_type, NULL, 0); if (!Del_type) return 0; Del_singleton = PyType_GenericNew(Del_type, NULL, NULL); if (!Del_singleton) return 0; AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0); if (!AugLoad_type) return 0; AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL); if (!AugLoad_singleton) return 0; AugStore_type = make_type("AugStore", expr_context_type, NULL, 0); if (!AugStore_type) return 0; AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL); if (!AugStore_singleton) return 0; Param_type = make_type("Param", expr_context_type, NULL, 0); if (!Param_type) return 0; Param_singleton = PyType_GenericNew(Param_type, NULL, NULL); if (!Param_singleton) return 0; slice_type = make_type("slice", &AST_type, NULL, 0); if (!slice_type) return 0; if (!add_attributes(slice_type, NULL, 0)) return 0; Ellipsis_type = make_type("Ellipsis", slice_type, NULL, 0); if (!Ellipsis_type) return 0; Slice_type = make_type("Slice", slice_type, Slice_fields, 3); if (!Slice_type) return 0; ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1); if (!ExtSlice_type) return 0; Index_type = make_type("Index", slice_type, Index_fields, 1); if (!Index_type) return 0; boolop_type = make_type("boolop", &AST_type, NULL, 0); if (!boolop_type) return 0; if (!add_attributes(boolop_type, NULL, 0)) return 0; And_type = make_type("And", boolop_type, NULL, 0); if (!And_type) return 0; And_singleton = PyType_GenericNew(And_type, NULL, NULL); if (!And_singleton) return 0; Or_type = make_type("Or", boolop_type, NULL, 0); if (!Or_type) return 0; Or_singleton = PyType_GenericNew(Or_type, NULL, NULL); if (!Or_singleton) return 0; operator_type = make_type("operator", &AST_type, NULL, 0); if (!operator_type) return 0; if (!add_attributes(operator_type, NULL, 0)) return 0; Add_type = make_type("Add", operator_type, NULL, 0); if (!Add_type) return 0; Add_singleton = PyType_GenericNew(Add_type, NULL, NULL); if (!Add_singleton) return 0; Sub_type = make_type("Sub", operator_type, NULL, 0); if (!Sub_type) return 0; Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL); if (!Sub_singleton) return 0; Mult_type = make_type("Mult", operator_type, NULL, 0); if (!Mult_type) return 0; Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL); if (!Mult_singleton) return 0; Div_type = make_type("Div", operator_type, NULL, 0); if (!Div_type) return 0; Div_singleton = PyType_GenericNew(Div_type, NULL, NULL); if (!Div_singleton) return 0; Mod_type = make_type("Mod", operator_type, NULL, 0); if (!Mod_type) return 0; Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL); if (!Mod_singleton) return 0; Pow_type = make_type("Pow", operator_type, NULL, 0); if (!Pow_type) return 0; Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL); if (!Pow_singleton) return 0; LShift_type = make_type("LShift", operator_type, NULL, 0); if (!LShift_type) return 0; LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL); if (!LShift_singleton) return 0; RShift_type = make_type("RShift", operator_type, NULL, 0); if (!RShift_type) return 0; RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL); if (!RShift_singleton) return 0; BitOr_type = make_type("BitOr", operator_type, NULL, 0); if (!BitOr_type) return 0; BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL); if (!BitOr_singleton) return 0; BitXor_type = make_type("BitXor", operator_type, NULL, 0); if (!BitXor_type) return 0; BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL); if (!BitXor_singleton) return 0; BitAnd_type = make_type("BitAnd", operator_type, NULL, 0); if (!BitAnd_type) return 0; BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL); if (!BitAnd_singleton) return 0; FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0); if (!FloorDiv_type) return 0; FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL); if (!FloorDiv_singleton) return 0; unaryop_type = make_type("unaryop", &AST_type, NULL, 0); if (!unaryop_type) return 0; if (!add_attributes(unaryop_type, NULL, 0)) return 0; Invert_type = make_type("Invert", unaryop_type, NULL, 0); if (!Invert_type) return 0; Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL); if (!Invert_singleton) return 0; Not_type = make_type("Not", unaryop_type, NULL, 0); if (!Not_type) return 0; Not_singleton = PyType_GenericNew(Not_type, NULL, NULL); if (!Not_singleton) return 0; UAdd_type = make_type("UAdd", unaryop_type, NULL, 0); if (!UAdd_type) return 0; UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL); if (!UAdd_singleton) return 0; USub_type = make_type("USub", unaryop_type, NULL, 0); if (!USub_type) return 0; USub_singleton = PyType_GenericNew(USub_type, NULL, NULL); if (!USub_singleton) return 0; cmpop_type = make_type("cmpop", &AST_type, NULL, 0); if (!cmpop_type) return 0; if (!add_attributes(cmpop_type, NULL, 0)) return 0; Eq_type = make_type("Eq", cmpop_type, NULL, 0); if (!Eq_type) return 0; Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL); if (!Eq_singleton) return 0; NotEq_type = make_type("NotEq", cmpop_type, NULL, 0); if (!NotEq_type) return 0; NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL); if (!NotEq_singleton) return 0; Lt_type = make_type("Lt", cmpop_type, NULL, 0); if (!Lt_type) return 0; Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL); if (!Lt_singleton) return 0; LtE_type = make_type("LtE", cmpop_type, NULL, 0); if (!LtE_type) return 0; LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL); if (!LtE_singleton) return 0; Gt_type = make_type("Gt", cmpop_type, NULL, 0); if (!Gt_type) return 0; Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL); if (!Gt_singleton) return 0; GtE_type = make_type("GtE", cmpop_type, NULL, 0); if (!GtE_type) return 0; GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL); if (!GtE_singleton) return 0; Is_type = make_type("Is", cmpop_type, NULL, 0); if (!Is_type) return 0; Is_singleton = PyType_GenericNew(Is_type, NULL, NULL); if (!Is_singleton) return 0; IsNot_type = make_type("IsNot", cmpop_type, NULL, 0); if (!IsNot_type) return 0; IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL); if (!IsNot_singleton) return 0; In_type = make_type("In", cmpop_type, NULL, 0); if (!In_type) return 0; In_singleton = PyType_GenericNew(In_type, NULL, NULL); if (!In_singleton) return 0; NotIn_type = make_type("NotIn", cmpop_type, NULL, 0); if (!NotIn_type) return 0; NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL); if (!NotIn_singleton) return 0; comprehension_type = make_type("comprehension", &AST_type, comprehension_fields, 3); if (!comprehension_type) return 0; excepthandler_type = make_type("excepthandler", &AST_type, NULL, 0); if (!excepthandler_type) return 0; if (!add_attributes(excepthandler_type, excepthandler_attributes, 2)) return 0; ExceptHandler_type = make_type("ExceptHandler", excepthandler_type, ExceptHandler_fields, 3); if (!ExceptHandler_type) return 0; arguments_type = make_type("arguments", &AST_type, arguments_fields, 5); if (!arguments_type) return 0; keyword_type = make_type("keyword", &AST_type, keyword_fields, 2); if (!keyword_type) return 0; alias_type = make_type("alias", &AST_type, alias_fields, 2); if (!alias_type) return 0; type_ignore_type = make_type("type_ignore", &AST_type, NULL, 0); if (!type_ignore_type) return 0; if (!add_attributes(type_ignore_type, NULL, 0)) return 0; TypeIgnore_type = make_type("TypeIgnore", type_ignore_type, TypeIgnore_fields, 1); if (!TypeIgnore_type) return 0; initialized = 1; return 1; } static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena); static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena); static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena); static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena); static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena); static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena); static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena); static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena); static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena); static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena); static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena); static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena); static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena); static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena); static int obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena* arena); mod_ty Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Module_kind; p->v.Module.body = body; p->v.Module.type_ignores = type_ignores; return p; } mod_ty Interactive(asdl_seq * body, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Interactive_kind; p->v.Interactive.body = body; return p; } mod_ty Expression(expr_ty body, PyArena *arena) { mod_ty p; if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for Expression"); return NULL; } p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Expression_kind; p->v.Expression.body = body; return p; } mod_ty FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena) { mod_ty p; if (!returns) { PyErr_SetString(PyExc_ValueError, "field returns is required for FunctionType"); return NULL; } p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = FunctionType_kind; p->v.FunctionType.argtypes = argtypes; p->v.FunctionType.returns = returns; return p; } mod_ty Suite(asdl_seq * body, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Suite_kind; p->v.Suite.body = body; return p; } stmt_ty FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for FunctionDef"); return NULL; } if (!args) { PyErr_SetString(PyExc_ValueError, "field args is required for FunctionDef"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = FunctionDef_kind; p->v.FunctionDef.name = name; p->v.FunctionDef.args = args; p->v.FunctionDef.body = body; p->v.FunctionDef.decorator_list = decorator_list; p->v.FunctionDef.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty ClassDef(identifier name, asdl_seq * bases, asdl_seq * body, asdl_seq * decorator_list, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for ClassDef"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ClassDef_kind; p->v.ClassDef.name = name; p->v.ClassDef.bases = bases; p->v.ClassDef.body = body; p->v.ClassDef.decorator_list = decorator_list; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Return(expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Return_kind; p->v.Return.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Delete_kind; p->v.Delete.targets = targets; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Assign"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Assign_kind; p->v.Assign.targets = targets; p->v.Assign.value = value; p->v.Assign.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for AugAssign"); return NULL; } if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for AugAssign"); return NULL; } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for AugAssign"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AugAssign_kind; p->v.AugAssign.target = target; p->v.AugAssign.op = op; p->v.AugAssign.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Print_kind; p->v.Print.dest = dest; p->v.Print.values = values; p->v.Print.nl = nl; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for For"); return NULL; } if (!iter) { PyErr_SetString(PyExc_ValueError, "field iter is required for For"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = For_kind; p->v.For.target = target; p->v.For.iter = iter; p->v.For.body = body; p->v.For.orelse = orelse; p->v.For.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for While"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = While_kind; p->v.While.test = test; p->v.While.body = body; p->v.While.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for If"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = If_kind; p->v.If.test = test; p->v.If.body = body; p->v.If.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!context_expr) { PyErr_SetString(PyExc_ValueError, "field context_expr is required for With"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = With_kind; p->v.With.context_expr = context_expr; p->v.With.optional_vars = optional_vars; p->v.With.body = body; p->v.With.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Raise_kind; p->v.Raise.type = type; p->v.Raise.inst = inst; p->v.Raise.tback = tback; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = TryExcept_kind; p->v.TryExcept.body = body; p->v.TryExcept.handlers = handlers; p->v.TryExcept.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = TryFinally_kind; p->v.TryFinally.body = body; p->v.TryFinally.finalbody = finalbody; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for Assert"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Assert_kind; p->v.Assert.test = test; p->v.Assert.msg = msg; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Import_kind; p->v.Import.names = names; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ImportFrom_kind; p->v.ImportFrom.module = module; p->v.ImportFrom.names = names; p->v.ImportFrom.level = level; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for Exec"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Exec_kind; p->v.Exec.body = body; p->v.Exec.globals = globals; p->v.Exec.locals = locals; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Global_kind; p->v.Global.names = names; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Expr(expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Expr"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Expr_kind; p->v.Expr.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Pass(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Pass_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Break(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Break_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Continue(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Continue_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for BoolOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = BoolOp_kind; p->v.BoolOp.op = op; p->v.BoolOp.values = values; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!left) { PyErr_SetString(PyExc_ValueError, "field left is required for BinOp"); return NULL; } if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for BinOp"); return NULL; } if (!right) { PyErr_SetString(PyExc_ValueError, "field right is required for BinOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = BinOp_kind; p->v.BinOp.left = left; p->v.BinOp.op = op; p->v.BinOp.right = right; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for UnaryOp"); return NULL; } if (!operand) { PyErr_SetString(PyExc_ValueError, "field operand is required for UnaryOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = UnaryOp_kind; p->v.UnaryOp.op = op; p->v.UnaryOp.operand = operand; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!args) { PyErr_SetString(PyExc_ValueError, "field args is required for Lambda"); return NULL; } if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for Lambda"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Lambda_kind; p->v.Lambda.args = args; p->v.Lambda.body = body; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for IfExp"); return NULL; } if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for IfExp"); return NULL; } if (!orelse) { PyErr_SetString(PyExc_ValueError, "field orelse is required for IfExp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = IfExp_kind; p->v.IfExp.test = test; p->v.IfExp.body = body; p->v.IfExp.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Dict_kind; p->v.Dict.keys = keys; p->v.Dict.values = values; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Set_kind; p->v.Set.elts = elts; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for ListComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ListComp_kind; p->v.ListComp.elt = elt; p->v.ListComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for SetComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = SetComp_kind; p->v.SetComp.elt = elt; p->v.SetComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!key) { PyErr_SetString(PyExc_ValueError, "field key is required for DictComp"); return NULL; } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for DictComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = DictComp_kind; p->v.DictComp.key = key; p->v.DictComp.value = value; p->v.DictComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for GeneratorExp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = GeneratorExp_kind; p->v.GeneratorExp.elt = elt; p->v.GeneratorExp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Yield(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Yield_kind; p->v.Yield.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!left) { PyErr_SetString(PyExc_ValueError, "field left is required for Compare"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Compare_kind; p->v.Compare.left = left; p->v.Compare.ops = ops; p->v.Compare.comparators = comparators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, expr_ty kwargs, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!func) { PyErr_SetString(PyExc_ValueError, "field func is required for Call"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Call_kind; p->v.Call.func = func; p->v.Call.args = args; p->v.Call.keywords = keywords; p->v.Call.starargs = starargs; p->v.Call.kwargs = kwargs; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Repr(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Repr"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Repr_kind; p->v.Repr.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Num(object n, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!n) { PyErr_SetString(PyExc_ValueError, "field n is required for Num"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Num_kind; p->v.Num.n = n; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Str(string s, int has_b, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!s) { PyErr_SetString(PyExc_ValueError, "field s is required for Str"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Str_kind; p->v.Str.s = s; p->v.Str.has_b = has_b; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Attribute"); return NULL; } if (!attr) { PyErr_SetString(PyExc_ValueError, "field attr is required for Attribute"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Attribute"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Attribute_kind; p->v.Attribute.value = value; p->v.Attribute.attr = attr; p->v.Attribute.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Subscript"); return NULL; } if (!slice) { PyErr_SetString(PyExc_ValueError, "field slice is required for Subscript"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Subscript"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Subscript_kind; p->v.Subscript.value = value; p->v.Subscript.slice = slice; p->v.Subscript.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!id) { PyErr_SetString(PyExc_ValueError, "field id is required for Name"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Name"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Name_kind; p->v.Name.id = id; p->v.Name.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for List"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = List_kind; p->v.List.elts = elts; p->v.List.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Tuple"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Tuple_kind; p->v.Tuple.elts = elts; p->v.Tuple.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } slice_ty Ellipsis(PyArena *arena) { slice_ty p; p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Ellipsis_kind; return p; } slice_ty Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena) { slice_ty p; p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Slice_kind; p->v.Slice.lower = lower; p->v.Slice.upper = upper; p->v.Slice.step = step; return p; } slice_ty ExtSlice(asdl_seq * dims, PyArena *arena) { slice_ty p; p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ExtSlice_kind; p->v.ExtSlice.dims = dims; return p; } slice_ty Index(expr_ty value, PyArena *arena) { slice_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Index"); return NULL; } p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Index_kind; p->v.Index.value = value; return p; } comprehension_ty comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, PyArena *arena) { comprehension_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for comprehension"); return NULL; } if (!iter) { PyErr_SetString(PyExc_ValueError, "field iter is required for comprehension"); return NULL; } p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->target = target; p->iter = iter; p->ifs = ifs; return p; } excepthandler_ty ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int col_offset, PyArena *arena) { excepthandler_ty p; p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ExceptHandler_kind; p->v.ExceptHandler.type = type; p->v.ExceptHandler.name = name; p->v.ExceptHandler.body = body; p->lineno = lineno; p->col_offset = col_offset; return p; } arguments_ty arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq * defaults, asdl_seq * type_comments, PyArena *arena) { arguments_ty p; p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->args = args; p->vararg = vararg; p->kwarg = kwarg; p->defaults = defaults; p->type_comments = type_comments; return p; } keyword_ty keyword(identifier arg, expr_ty value, PyArena *arena) { keyword_ty p; if (!arg) { PyErr_SetString(PyExc_ValueError, "field arg is required for keyword"); return NULL; } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for keyword"); return NULL; } p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->arg = arg; p->value = value; return p; } alias_ty alias(identifier name, identifier asname, PyArena *arena) { alias_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for alias"); return NULL; } p = (alias_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->name = name; p->asname = asname; return p; } type_ignore_ty TypeIgnore(int lineno, PyArena *arena) { type_ignore_ty p; p = (type_ignore_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = TypeIgnore_kind; p->v.TypeIgnore.lineno = lineno; return p; } PyObject* ast2obj_mod(void* _o) { mod_ty o = (mod_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case Module_kind: result = PyType_GenericNew(Module_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Module.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Module.type_ignores, ast2obj_type_ignore); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_ignores", value) == -1) goto failed; Py_DECREF(value); break; case Interactive_kind: result = PyType_GenericNew(Interactive_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); break; case Expression_kind: result = PyType_GenericNew(Expression_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Expression.body); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); break; case FunctionType_kind: result = PyType_GenericNew(FunctionType_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.FunctionType.argtypes, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "argtypes", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.FunctionType.returns); if (!value) goto failed; if (PyObject_SetAttrString(result, "returns", value) == -1) goto failed; Py_DECREF(value); break; case Suite_kind: result = PyType_GenericNew(Suite_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Suite.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_stmt(void* _o) { stmt_ty o = (stmt_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case FunctionDef_kind: result = PyType_GenericNew(FunctionDef_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.FunctionDef.name); if (!value) goto failed; if (PyObject_SetAttrString(result, "name", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_arguments(o->v.FunctionDef.args); if (!value) goto failed; if (PyObject_SetAttrString(result, "args", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.FunctionDef.decorator_list, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "decorator_list", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.FunctionDef.type_comment); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_comment", value) == -1) goto failed; Py_DECREF(value); break; case ClassDef_kind: result = PyType_GenericNew(ClassDef_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.ClassDef.name); if (!value) goto failed; if (PyObject_SetAttrString(result, "name", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "bases", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.decorator_list, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "decorator_list", value) == -1) goto failed; Py_DECREF(value); break; case Return_kind: result = PyType_GenericNew(Return_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Return.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; case Delete_kind: result = PyType_GenericNew(Delete_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Delete.targets, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "targets", value) == -1) goto failed; Py_DECREF(value); break; case Assign_kind: result = PyType_GenericNew(Assign_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Assign.targets, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "targets", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Assign.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.Assign.type_comment); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_comment", value) == -1) goto failed; Py_DECREF(value); break; case AugAssign_kind: result = PyType_GenericNew(AugAssign_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.AugAssign.target); if (!value) goto failed; if (PyObject_SetAttrString(result, "target", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_operator(o->v.AugAssign.op); if (!value) goto failed; if (PyObject_SetAttrString(result, "op", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AugAssign.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; case Print_kind: result = PyType_GenericNew(Print_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Print.dest); if (!value) goto failed; if (PyObject_SetAttrString(result, "dest", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Print.values, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "values", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_bool(o->v.Print.nl); if (!value) goto failed; if (PyObject_SetAttrString(result, "nl", value) == -1) goto failed; Py_DECREF(value); break; case For_kind: result = PyType_GenericNew(For_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.For.target); if (!value) goto failed; if (PyObject_SetAttrString(result, "target", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.For.iter); if (!value) goto failed; if (PyObject_SetAttrString(result, "iter", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.For.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.For.orelse, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "orelse", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.For.type_comment); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_comment", value) == -1) goto failed; Py_DECREF(value); break; case While_kind: result = PyType_GenericNew(While_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.While.test); if (!value) goto failed; if (PyObject_SetAttrString(result, "test", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.While.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.While.orelse, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "orelse", value) == -1) goto failed; Py_DECREF(value); break; case If_kind: result = PyType_GenericNew(If_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.If.test); if (!value) goto failed; if (PyObject_SetAttrString(result, "test", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.If.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.If.orelse, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "orelse", value) == -1) goto failed; Py_DECREF(value); break; case With_kind: result = PyType_GenericNew(With_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.With.context_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "context_expr", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.With.optional_vars); if (!value) goto failed; if (PyObject_SetAttrString(result, "optional_vars", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.With.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.With.type_comment); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_comment", value) == -1) goto failed; Py_DECREF(value); break; case Raise_kind: result = PyType_GenericNew(Raise_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Raise.type); if (!value) goto failed; if (PyObject_SetAttrString(result, "type", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Raise.inst); if (!value) goto failed; if (PyObject_SetAttrString(result, "inst", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Raise.tback); if (!value) goto failed; if (PyObject_SetAttrString(result, "tback", value) == -1) goto failed; Py_DECREF(value); break; case TryExcept_kind: result = PyType_GenericNew(TryExcept_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.TryExcept.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.TryExcept.handlers, ast2obj_excepthandler); if (!value) goto failed; if (PyObject_SetAttrString(result, "handlers", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.TryExcept.orelse, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "orelse", value) == -1) goto failed; Py_DECREF(value); break; case TryFinally_kind: result = PyType_GenericNew(TryFinally_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.TryFinally.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.TryFinally.finalbody, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "finalbody", value) == -1) goto failed; Py_DECREF(value); break; case Assert_kind: result = PyType_GenericNew(Assert_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Assert.test); if (!value) goto failed; if (PyObject_SetAttrString(result, "test", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Assert.msg); if (!value) goto failed; if (PyObject_SetAttrString(result, "msg", value) == -1) goto failed; Py_DECREF(value); break; case Import_kind: result = PyType_GenericNew(Import_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Import.names, ast2obj_alias); if (!value) goto failed; if (PyObject_SetAttrString(result, "names", value) == -1) goto failed; Py_DECREF(value); break; case ImportFrom_kind: result = PyType_GenericNew(ImportFrom_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.ImportFrom.module); if (!value) goto failed; if (PyObject_SetAttrString(result, "module", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias); if (!value) goto failed; if (PyObject_SetAttrString(result, "names", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->v.ImportFrom.level); if (!value) goto failed; if (PyObject_SetAttrString(result, "level", value) == -1) goto failed; Py_DECREF(value); break; case Exec_kind: result = PyType_GenericNew(Exec_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Exec.body); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Exec.globals); if (!value) goto failed; if (PyObject_SetAttrString(result, "globals", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Exec.locals); if (!value) goto failed; if (PyObject_SetAttrString(result, "locals", value) == -1) goto failed; Py_DECREF(value); break; case Global_kind: result = PyType_GenericNew(Global_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Global.names, ast2obj_identifier); if (!value) goto failed; if (PyObject_SetAttrString(result, "names", value) == -1) goto failed; Py_DECREF(value); break; case Expr_kind: result = PyType_GenericNew(Expr_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Expr.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; case Pass_kind: result = PyType_GenericNew(Pass_type, NULL, NULL); if (!result) goto failed; break; case Break_kind: result = PyType_GenericNew(Break_type, NULL, NULL); if (!result) goto failed; break; case Continue_kind: result = PyType_GenericNew(Continue_type, NULL, NULL); if (!result) goto failed; break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (PyObject_SetAttrString(result, "lineno", value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (PyObject_SetAttrString(result, "col_offset", value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_expr(void* _o) { expr_ty o = (expr_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case BoolOp_kind: result = PyType_GenericNew(BoolOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_boolop(o->v.BoolOp.op); if (!value) goto failed; if (PyObject_SetAttrString(result, "op", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "values", value) == -1) goto failed; Py_DECREF(value); break; case BinOp_kind: result = PyType_GenericNew(BinOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.BinOp.left); if (!value) goto failed; if (PyObject_SetAttrString(result, "left", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_operator(o->v.BinOp.op); if (!value) goto failed; if (PyObject_SetAttrString(result, "op", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.BinOp.right); if (!value) goto failed; if (PyObject_SetAttrString(result, "right", value) == -1) goto failed; Py_DECREF(value); break; case UnaryOp_kind: result = PyType_GenericNew(UnaryOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_unaryop(o->v.UnaryOp.op); if (!value) goto failed; if (PyObject_SetAttrString(result, "op", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.UnaryOp.operand); if (!value) goto failed; if (PyObject_SetAttrString(result, "operand", value) == -1) goto failed; Py_DECREF(value); break; case Lambda_kind: result = PyType_GenericNew(Lambda_type, NULL, NULL); if (!result) goto failed; value = ast2obj_arguments(o->v.Lambda.args); if (!value) goto failed; if (PyObject_SetAttrString(result, "args", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Lambda.body); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); break; case IfExp_kind: result = PyType_GenericNew(IfExp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.IfExp.test); if (!value) goto failed; if (PyObject_SetAttrString(result, "test", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.IfExp.body); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.IfExp.orelse); if (!value) goto failed; if (PyObject_SetAttrString(result, "orelse", value) == -1) goto failed; Py_DECREF(value); break; case Dict_kind: result = PyType_GenericNew(Dict_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Dict.keys, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "keys", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Dict.values, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "values", value) == -1) goto failed; Py_DECREF(value); break; case Set_kind: result = PyType_GenericNew(Set_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Set.elts, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "elts", value) == -1) goto failed; Py_DECREF(value); break; case ListComp_kind: result = PyType_GenericNew(ListComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.ListComp.elt); if (!value) goto failed; if (PyObject_SetAttrString(result, "elt", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ListComp.generators, ast2obj_comprehension); if (!value) goto failed; if (PyObject_SetAttrString(result, "generators", value) == -1) goto failed; Py_DECREF(value); break; case SetComp_kind: result = PyType_GenericNew(SetComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.SetComp.elt); if (!value) goto failed; if (PyObject_SetAttrString(result, "elt", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.SetComp.generators, ast2obj_comprehension); if (!value) goto failed; if (PyObject_SetAttrString(result, "generators", value) == -1) goto failed; Py_DECREF(value); break; case DictComp_kind: result = PyType_GenericNew(DictComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.DictComp.key); if (!value) goto failed; if (PyObject_SetAttrString(result, "key", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.DictComp.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.DictComp.generators, ast2obj_comprehension); if (!value) goto failed; if (PyObject_SetAttrString(result, "generators", value) == -1) goto failed; Py_DECREF(value); break; case GeneratorExp_kind: result = PyType_GenericNew(GeneratorExp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.GeneratorExp.elt); if (!value) goto failed; if (PyObject_SetAttrString(result, "elt", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.GeneratorExp.generators, ast2obj_comprehension); if (!value) goto failed; if (PyObject_SetAttrString(result, "generators", value) == -1) goto failed; Py_DECREF(value); break; case Yield_kind: result = PyType_GenericNew(Yield_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Yield.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; case Compare_kind: result = PyType_GenericNew(Compare_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Compare.left); if (!value) goto failed; if (PyObject_SetAttrString(result, "left", value) == -1) goto failed; Py_DECREF(value); { int i, n = asdl_seq_LEN(o->v.Compare.ops); value = PyList_New(n); if (!value) goto failed; for(i = 0; i < n; i++) PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i))); } if (!value) goto failed; if (PyObject_SetAttrString(result, "ops", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "comparators", value) == -1) goto failed; Py_DECREF(value); break; case Call_kind: result = PyType_GenericNew(Call_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Call.func); if (!value) goto failed; if (PyObject_SetAttrString(result, "func", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Call.args, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "args", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword); if (!value) goto failed; if (PyObject_SetAttrString(result, "keywords", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Call.starargs); if (!value) goto failed; if (PyObject_SetAttrString(result, "starargs", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Call.kwargs); if (!value) goto failed; if (PyObject_SetAttrString(result, "kwargs", value) == -1) goto failed; Py_DECREF(value); break; case Repr_kind: result = PyType_GenericNew(Repr_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Repr.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; case Num_kind: result = PyType_GenericNew(Num_type, NULL, NULL); if (!result) goto failed; value = ast2obj_object(o->v.Num.n); if (!value) goto failed; if (PyObject_SetAttrString(result, "n", value) == -1) goto failed; Py_DECREF(value); break; case Str_kind: result = PyType_GenericNew(Str_type, NULL, NULL); if (!result) goto failed; value = ast2obj_string(o->v.Str.s); if (!value) goto failed; if (PyObject_SetAttrString(result, "s", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->v.Str.has_b); if (!value) goto failed; if (PyObject_SetAttrString(result, "has_b", value) == -1) goto failed; Py_DECREF(value); break; case Attribute_kind: result = PyType_GenericNew(Attribute_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Attribute.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->v.Attribute.attr); if (!value) goto failed; if (PyObject_SetAttrString(result, "attr", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Attribute.ctx); if (!value) goto failed; if (PyObject_SetAttrString(result, "ctx", value) == -1) goto failed; Py_DECREF(value); break; case Subscript_kind: result = PyType_GenericNew(Subscript_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Subscript.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_slice(o->v.Subscript.slice); if (!value) goto failed; if (PyObject_SetAttrString(result, "slice", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Subscript.ctx); if (!value) goto failed; if (PyObject_SetAttrString(result, "ctx", value) == -1) goto failed; Py_DECREF(value); break; case Name_kind: result = PyType_GenericNew(Name_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.Name.id); if (!value) goto failed; if (PyObject_SetAttrString(result, "id", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Name.ctx); if (!value) goto failed; if (PyObject_SetAttrString(result, "ctx", value) == -1) goto failed; Py_DECREF(value); break; case List_kind: result = PyType_GenericNew(List_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.List.elts, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "elts", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.List.ctx); if (!value) goto failed; if (PyObject_SetAttrString(result, "ctx", value) == -1) goto failed; Py_DECREF(value); break; case Tuple_kind: result = PyType_GenericNew(Tuple_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "elts", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Tuple.ctx); if (!value) goto failed; if (PyObject_SetAttrString(result, "ctx", value) == -1) goto failed; Py_DECREF(value); break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (PyObject_SetAttrString(result, "lineno", value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (PyObject_SetAttrString(result, "col_offset", value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_expr_context(expr_context_ty o) { switch(o) { case Load: Py_INCREF(Load_singleton); return Load_singleton; case Store: Py_INCREF(Store_singleton); return Store_singleton; case Del: Py_INCREF(Del_singleton); return Del_singleton; case AugLoad: Py_INCREF(AugLoad_singleton); return AugLoad_singleton; case AugStore: Py_INCREF(AugStore_singleton); return AugStore_singleton; case Param: Py_INCREF(Param_singleton); return Param_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown expr_context found"); return NULL; } } PyObject* ast2obj_slice(void* _o) { slice_ty o = (slice_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case Ellipsis_kind: result = PyType_GenericNew(Ellipsis_type, NULL, NULL); if (!result) goto failed; break; case Slice_kind: result = PyType_GenericNew(Slice_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Slice.lower); if (!value) goto failed; if (PyObject_SetAttrString(result, "lower", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Slice.upper); if (!value) goto failed; if (PyObject_SetAttrString(result, "upper", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Slice.step); if (!value) goto failed; if (PyObject_SetAttrString(result, "step", value) == -1) goto failed; Py_DECREF(value); break; case ExtSlice_kind: result = PyType_GenericNew(ExtSlice_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice); if (!value) goto failed; if (PyObject_SetAttrString(result, "dims", value) == -1) goto failed; Py_DECREF(value); break; case Index_kind: result = PyType_GenericNew(Index_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Index.value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_boolop(boolop_ty o) { switch(o) { case And: Py_INCREF(And_singleton); return And_singleton; case Or: Py_INCREF(Or_singleton); return Or_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown boolop found"); return NULL; } } PyObject* ast2obj_operator(operator_ty o) { switch(o) { case Add: Py_INCREF(Add_singleton); return Add_singleton; case Sub: Py_INCREF(Sub_singleton); return Sub_singleton; case Mult: Py_INCREF(Mult_singleton); return Mult_singleton; case Div: Py_INCREF(Div_singleton); return Div_singleton; case Mod: Py_INCREF(Mod_singleton); return Mod_singleton; case Pow: Py_INCREF(Pow_singleton); return Pow_singleton; case LShift: Py_INCREF(LShift_singleton); return LShift_singleton; case RShift: Py_INCREF(RShift_singleton); return RShift_singleton; case BitOr: Py_INCREF(BitOr_singleton); return BitOr_singleton; case BitXor: Py_INCREF(BitXor_singleton); return BitXor_singleton; case BitAnd: Py_INCREF(BitAnd_singleton); return BitAnd_singleton; case FloorDiv: Py_INCREF(FloorDiv_singleton); return FloorDiv_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown operator found"); return NULL; } } PyObject* ast2obj_unaryop(unaryop_ty o) { switch(o) { case Invert: Py_INCREF(Invert_singleton); return Invert_singleton; case Not: Py_INCREF(Not_singleton); return Not_singleton; case UAdd: Py_INCREF(UAdd_singleton); return UAdd_singleton; case USub: Py_INCREF(USub_singleton); return USub_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown unaryop found"); return NULL; } } PyObject* ast2obj_cmpop(cmpop_ty o) { switch(o) { case Eq: Py_INCREF(Eq_singleton); return Eq_singleton; case NotEq: Py_INCREF(NotEq_singleton); return NotEq_singleton; case Lt: Py_INCREF(Lt_singleton); return Lt_singleton; case LtE: Py_INCREF(LtE_singleton); return LtE_singleton; case Gt: Py_INCREF(Gt_singleton); return Gt_singleton; case GtE: Py_INCREF(GtE_singleton); return GtE_singleton; case Is: Py_INCREF(Is_singleton); return Is_singleton; case IsNot: Py_INCREF(IsNot_singleton); return IsNot_singleton; case In: Py_INCREF(In_singleton); return In_singleton; case NotIn: Py_INCREF(NotIn_singleton); return NotIn_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown cmpop found"); return NULL; } } PyObject* ast2obj_comprehension(void* _o) { comprehension_ty o = (comprehension_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(comprehension_type, NULL, NULL); if (!result) return NULL; value = ast2obj_expr(o->target); if (!value) goto failed; if (PyObject_SetAttrString(result, "target", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->iter); if (!value) goto failed; if (PyObject_SetAttrString(result, "iter", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->ifs, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "ifs", value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_excepthandler(void* _o) { excepthandler_ty o = (excepthandler_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case ExceptHandler_kind: result = PyType_GenericNew(ExceptHandler_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.ExceptHandler.type); if (!value) goto failed; if (PyObject_SetAttrString(result, "type", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.ExceptHandler.name); if (!value) goto failed; if (PyObject_SetAttrString(result, "name", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt); if (!value) goto failed; if (PyObject_SetAttrString(result, "body", value) == -1) goto failed; Py_DECREF(value); break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (PyObject_SetAttrString(result, "lineno", value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (PyObject_SetAttrString(result, "col_offset", value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_arguments(void* _o) { arguments_ty o = (arguments_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(arguments_type, NULL, NULL); if (!result) return NULL; value = ast2obj_list(o->args, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "args", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->vararg); if (!value) goto failed; if (PyObject_SetAttrString(result, "vararg", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->kwarg); if (!value) goto failed; if (PyObject_SetAttrString(result, "kwarg", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->defaults, ast2obj_expr); if (!value) goto failed; if (PyObject_SetAttrString(result, "defaults", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->type_comments, ast2obj_string); if (!value) goto failed; if (PyObject_SetAttrString(result, "type_comments", value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_keyword(void* _o) { keyword_ty o = (keyword_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(keyword_type, NULL, NULL); if (!result) return NULL; value = ast2obj_identifier(o->arg); if (!value) goto failed; if (PyObject_SetAttrString(result, "arg", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->value); if (!value) goto failed; if (PyObject_SetAttrString(result, "value", value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_alias(void* _o) { alias_ty o = (alias_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(alias_type, NULL, NULL); if (!result) return NULL; value = ast2obj_identifier(o->name); if (!value) goto failed; if (PyObject_SetAttrString(result, "name", value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->asname); if (!value) goto failed; if (PyObject_SetAttrString(result, "asname", value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_type_ignore(void* _o) { type_ignore_ty o = (type_ignore_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case TypeIgnore_kind: result = PyType_GenericNew(TypeIgnore_type, NULL, NULL); if (!result) goto failed; value = ast2obj_int(o->v.TypeIgnore.lineno); if (!value) goto failed; if (PyObject_SetAttrString(result, "lineno", value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Module_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; asdl_seq* type_ignores; if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module"); return 1; } if (PyObject_HasAttrString(obj, "type_ignores")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "type_ignores"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); type_ignores = asdl_seq_new(len, arena); if (type_ignores == NULL) goto failed; for (i = 0; i < len; i++) { type_ignore_ty value; res = obj2ast_type_ignore(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(type_ignores, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module"); return 1; } *out = Module(body, type_ignores, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Interactive_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive"); return 1; } *out = Interactive(body, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Expression_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty body; if (PyObject_HasAttrString(obj, "body")) { int res; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression"); return 1; } *out = Expression(body, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionType_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* argtypes; expr_ty returns; if (PyObject_HasAttrString(obj, "argtypes")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "argtypes"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); argtypes = asdl_seq_new(len, arena); if (argtypes == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(argtypes, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType"); return 1; } if (PyObject_HasAttrString(obj, "returns")) { int res; tmp = PyObject_GetAttrString(obj, "returns"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &returns, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType"); return 1; } *out = FunctionType(argtypes, returns, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Suite_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Suite field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Suite"); return 1; } *out = Suite(body, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (PyObject_HasAttrString(obj, "lineno")) { int res; tmp = PyObject_GetAttrString(obj, "lineno"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt"); return 1; } if (PyObject_HasAttrString(obj, "col_offset")) { int res; tmp = PyObject_GetAttrString(obj, "col_offset"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionDef_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier name; arguments_ty args; asdl_seq* body; asdl_seq* decorator_list; string type_comment; if (PyObject_HasAttrString(obj, "name")) { int res; tmp = PyObject_GetAttrString(obj, "name"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef"); return 1; } if (PyObject_HasAttrString(obj, "args")) { int res; tmp = PyObject_GetAttrString(obj, "args"); if (tmp == NULL) goto failed; res = obj2ast_arguments(tmp, &args, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef"); return 1; } if (PyObject_HasAttrString(obj, "decorator_list")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "decorator_list"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); decorator_list = asdl_seq_new(len, arena); if (decorator_list == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(decorator_list, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef"); return 1; } if (PyObject_HasAttrString(obj, "type_comment")) { int res; tmp = PyObject_GetAttrString(obj, "type_comment"); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type_comment = NULL; } *out = FunctionDef(name, args, body, decorator_list, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ClassDef_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier name; asdl_seq* bases; asdl_seq* body; asdl_seq* decorator_list; if (PyObject_HasAttrString(obj, "name")) { int res; tmp = PyObject_GetAttrString(obj, "name"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef"); return 1; } if (PyObject_HasAttrString(obj, "bases")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "bases"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); bases = asdl_seq_new(len, arena); if (bases == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(bases, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef"); return 1; } if (PyObject_HasAttrString(obj, "decorator_list")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "decorator_list"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); decorator_list = asdl_seq_new(len, arena); if (decorator_list == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(decorator_list, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef"); return 1; } *out = ClassDef(name, bases, body, decorator_list, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Return_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { value = NULL; } *out = Return(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Delete_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* targets; if (PyObject_HasAttrString(obj, "targets")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "targets"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); targets = asdl_seq_new(len, arena); if (targets == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(targets, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete"); return 1; } *out = Delete(targets, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Assign_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* targets; expr_ty value; string type_comment; if (PyObject_HasAttrString(obj, "targets")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "targets"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); targets = asdl_seq_new(len, arena); if (targets == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(targets, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign"); return 1; } if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign"); return 1; } if (PyObject_HasAttrString(obj, "type_comment")) { int res; tmp = PyObject_GetAttrString(obj, "type_comment"); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type_comment = NULL; } *out = Assign(targets, value, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AugAssign_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; operator_ty op; expr_ty value; if (PyObject_HasAttrString(obj, "target")) { int res; tmp = PyObject_GetAttrString(obj, "target"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign"); return 1; } if (PyObject_HasAttrString(obj, "op")) { int res; tmp = PyObject_GetAttrString(obj, "op"); if (tmp == NULL) goto failed; res = obj2ast_operator(tmp, &op, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign"); return 1; } if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign"); return 1; } *out = AugAssign(target, op, value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Print_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty dest; asdl_seq* values; bool nl; if (PyObject_HasAttrString(obj, "dest")) { int res; tmp = PyObject_GetAttrString(obj, "dest"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &dest, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { dest = NULL; } if (PyObject_HasAttrString(obj, "values")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "values"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Print field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(values, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Print"); return 1; } if (PyObject_HasAttrString(obj, "nl")) { int res; tmp = PyObject_GetAttrString(obj, "nl"); if (tmp == NULL) goto failed; res = obj2ast_bool(tmp, &nl, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"nl\" missing from Print"); return 1; } *out = Print(dest, values, nl, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)For_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; expr_ty iter; asdl_seq* body; asdl_seq* orelse; string type_comment; if (PyObject_HasAttrString(obj, "target")) { int res; tmp = PyObject_GetAttrString(obj, "target"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For"); return 1; } if (PyObject_HasAttrString(obj, "iter")) { int res; tmp = PyObject_GetAttrString(obj, "iter"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &iter, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For"); return 1; } if (PyObject_HasAttrString(obj, "orelse")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "orelse"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(orelse, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For"); return 1; } if (PyObject_HasAttrString(obj, "type_comment")) { int res; tmp = PyObject_GetAttrString(obj, "type_comment"); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type_comment = NULL; } *out = For(target, iter, body, orelse, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)While_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; asdl_seq* body; asdl_seq* orelse; if (PyObject_HasAttrString(obj, "test")) { int res; tmp = PyObject_GetAttrString(obj, "test"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While"); return 1; } if (PyObject_HasAttrString(obj, "orelse")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "orelse"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(orelse, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While"); return 1; } *out = While(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)If_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; asdl_seq* body; asdl_seq* orelse; if (PyObject_HasAttrString(obj, "test")) { int res; tmp = PyObject_GetAttrString(obj, "test"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If"); return 1; } if (PyObject_HasAttrString(obj, "orelse")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "orelse"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(orelse, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If"); return 1; } *out = If(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)With_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty context_expr; expr_ty optional_vars; asdl_seq* body; string type_comment; if (PyObject_HasAttrString(obj, "context_expr")) { int res; tmp = PyObject_GetAttrString(obj, "context_expr"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &context_expr, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from With"); return 1; } if (PyObject_HasAttrString(obj, "optional_vars")) { int res; tmp = PyObject_GetAttrString(obj, "optional_vars"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &optional_vars, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { optional_vars = NULL; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With"); return 1; } if (PyObject_HasAttrString(obj, "type_comment")) { int res; tmp = PyObject_GetAttrString(obj, "type_comment"); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type_comment = NULL; } *out = With(context_expr, optional_vars, body, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Raise_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty type; expr_ty inst; expr_ty tback; if (PyObject_HasAttrString(obj, "type")) { int res; tmp = PyObject_GetAttrString(obj, "type"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &type, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type = NULL; } if (PyObject_HasAttrString(obj, "inst")) { int res; tmp = PyObject_GetAttrString(obj, "inst"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &inst, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { inst = NULL; } if (PyObject_HasAttrString(obj, "tback")) { int res; tmp = PyObject_GetAttrString(obj, "tback"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &tback, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { tback = NULL; } *out = Raise(type, inst, tback, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)TryExcept_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; asdl_seq* handlers; asdl_seq* orelse; if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "TryExcept field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryExcept"); return 1; } if (PyObject_HasAttrString(obj, "handlers")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "handlers"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "TryExcept field \"handlers\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); handlers = asdl_seq_new(len, arena); if (handlers == NULL) goto failed; for (i = 0; i < len; i++) { excepthandler_ty value; res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(handlers, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from TryExcept"); return 1; } if (PyObject_HasAttrString(obj, "orelse")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "orelse"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "TryExcept field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(orelse, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from TryExcept"); return 1; } *out = TryExcept(body, handlers, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)TryFinally_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; asdl_seq* finalbody; if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "TryFinally field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from TryFinally"); return 1; } if (PyObject_HasAttrString(obj, "finalbody")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "finalbody"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "TryFinally field \"finalbody\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); finalbody = asdl_seq_new(len, arena); if (finalbody == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(finalbody, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from TryFinally"); return 1; } *out = TryFinally(body, finalbody, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Assert_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; expr_ty msg; if (PyObject_HasAttrString(obj, "test")) { int res; tmp = PyObject_GetAttrString(obj, "test"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert"); return 1; } if (PyObject_HasAttrString(obj, "msg")) { int res; tmp = PyObject_GetAttrString(obj, "msg"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &msg, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { msg = NULL; } *out = Assert(test, msg, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Import_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* names; if (PyObject_HasAttrString(obj, "names")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "names"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { alias_ty value; res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(names, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import"); return 1; } *out = Import(names, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ImportFrom_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier module; asdl_seq* names; int level; if (PyObject_HasAttrString(obj, "module")) { int res; tmp = PyObject_GetAttrString(obj, "module"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &module, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { module = NULL; } if (PyObject_HasAttrString(obj, "names")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "names"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { alias_ty value; res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(names, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom"); return 1; } if (PyObject_HasAttrString(obj, "level")) { int res; tmp = PyObject_GetAttrString(obj, "level"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &level, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { level = 0; } *out = ImportFrom(module, names, level, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Exec_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty body; expr_ty globals; expr_ty locals; if (PyObject_HasAttrString(obj, "body")) { int res; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Exec"); return 1; } if (PyObject_HasAttrString(obj, "globals")) { int res; tmp = PyObject_GetAttrString(obj, "globals"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &globals, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { globals = NULL; } if (PyObject_HasAttrString(obj, "locals")) { int res; tmp = PyObject_GetAttrString(obj, "locals"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &locals, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { locals = NULL; } *out = Exec(body, globals, locals, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Global_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* names; if (PyObject_HasAttrString(obj, "names")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "names"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { identifier value; res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(names, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global"); return 1; } *out = Global(names, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Expr_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr"); return 1; } *out = Expr(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Pass_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Pass(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Break_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Break(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Continue_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Continue(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (PyObject_HasAttrString(obj, "lineno")) { int res; tmp = PyObject_GetAttrString(obj, "lineno"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr"); return 1; } if (PyObject_HasAttrString(obj, "col_offset")) { int res; tmp = PyObject_GetAttrString(obj, "col_offset"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)BoolOp_type); if (isinstance == -1) { return 1; } if (isinstance) { boolop_ty op; asdl_seq* values; if (PyObject_HasAttrString(obj, "op")) { int res; tmp = PyObject_GetAttrString(obj, "op"); if (tmp == NULL) goto failed; res = obj2ast_boolop(tmp, &op, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp"); return 1; } if (PyObject_HasAttrString(obj, "values")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "values"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(values, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp"); return 1; } *out = BoolOp(op, values, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)BinOp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty left; operator_ty op; expr_ty right; if (PyObject_HasAttrString(obj, "left")) { int res; tmp = PyObject_GetAttrString(obj, "left"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &left, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp"); return 1; } if (PyObject_HasAttrString(obj, "op")) { int res; tmp = PyObject_GetAttrString(obj, "op"); if (tmp == NULL) goto failed; res = obj2ast_operator(tmp, &op, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp"); return 1; } if (PyObject_HasAttrString(obj, "right")) { int res; tmp = PyObject_GetAttrString(obj, "right"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &right, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp"); return 1; } *out = BinOp(left, op, right, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)UnaryOp_type); if (isinstance == -1) { return 1; } if (isinstance) { unaryop_ty op; expr_ty operand; if (PyObject_HasAttrString(obj, "op")) { int res; tmp = PyObject_GetAttrString(obj, "op"); if (tmp == NULL) goto failed; res = obj2ast_unaryop(tmp, &op, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp"); return 1; } if (PyObject_HasAttrString(obj, "operand")) { int res; tmp = PyObject_GetAttrString(obj, "operand"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &operand, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp"); return 1; } *out = UnaryOp(op, operand, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Lambda_type); if (isinstance == -1) { return 1; } if (isinstance) { arguments_ty args; expr_ty body; if (PyObject_HasAttrString(obj, "args")) { int res; tmp = PyObject_GetAttrString(obj, "args"); if (tmp == NULL) goto failed; res = obj2ast_arguments(tmp, &args, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda"); return 1; } *out = Lambda(args, body, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)IfExp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; expr_ty body; expr_ty orelse; if (PyObject_HasAttrString(obj, "test")) { int res; tmp = PyObject_GetAttrString(obj, "test"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp"); return 1; } if (PyObject_HasAttrString(obj, "body")) { int res; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp"); return 1; } if (PyObject_HasAttrString(obj, "orelse")) { int res; tmp = PyObject_GetAttrString(obj, "orelse"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &orelse, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp"); return 1; } *out = IfExp(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Dict_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* keys; asdl_seq* values; if (PyObject_HasAttrString(obj, "keys")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "keys"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); keys = asdl_seq_new(len, arena); if (keys == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(keys, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict"); return 1; } if (PyObject_HasAttrString(obj, "values")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "values"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(values, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict"); return 1; } *out = Dict(keys, values, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Set_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; if (PyObject_HasAttrString(obj, "elts")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "elts"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(elts, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set"); return 1; } *out = Set(elts, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ListComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (PyObject_HasAttrString(obj, "elt")) { int res; tmp = PyObject_GetAttrString(obj, "elt"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp"); return 1; } if (PyObject_HasAttrString(obj, "generators")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "generators"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(generators, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp"); return 1; } *out = ListComp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)SetComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (PyObject_HasAttrString(obj, "elt")) { int res; tmp = PyObject_GetAttrString(obj, "elt"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp"); return 1; } if (PyObject_HasAttrString(obj, "generators")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "generators"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(generators, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp"); return 1; } *out = SetComp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)DictComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty key; expr_ty value; asdl_seq* generators; if (PyObject_HasAttrString(obj, "key")) { int res; tmp = PyObject_GetAttrString(obj, "key"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &key, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp"); return 1; } if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp"); return 1; } if (PyObject_HasAttrString(obj, "generators")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "generators"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(generators, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp"); return 1; } *out = DictComp(key, value, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)GeneratorExp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (PyObject_HasAttrString(obj, "elt")) { int res; tmp = PyObject_GetAttrString(obj, "elt"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp"); return 1; } if (PyObject_HasAttrString(obj, "generators")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "generators"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(generators, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp"); return 1; } *out = GeneratorExp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Yield_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { value = NULL; } *out = Yield(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Compare_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty left; asdl_int_seq* ops; asdl_seq* comparators; if (PyObject_HasAttrString(obj, "left")) { int res; tmp = PyObject_GetAttrString(obj, "left"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &left, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare"); return 1; } if (PyObject_HasAttrString(obj, "ops")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "ops"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); ops = asdl_int_seq_new(len, arena); if (ops == NULL) goto failed; for (i = 0; i < len; i++) { cmpop_ty value; res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(ops, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare"); return 1; } if (PyObject_HasAttrString(obj, "comparators")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "comparators"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); comparators = asdl_seq_new(len, arena); if (comparators == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(comparators, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare"); return 1; } *out = Compare(left, ops, comparators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Call_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty func; asdl_seq* args; asdl_seq* keywords; expr_ty starargs; expr_ty kwargs; if (PyObject_HasAttrString(obj, "func")) { int res; tmp = PyObject_GetAttrString(obj, "func"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &func, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call"); return 1; } if (PyObject_HasAttrString(obj, "args")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "args"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); args = asdl_seq_new(len, arena); if (args == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(args, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call"); return 1; } if (PyObject_HasAttrString(obj, "keywords")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "keywords"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); keywords = asdl_seq_new(len, arena); if (keywords == NULL) goto failed; for (i = 0; i < len; i++) { keyword_ty value; res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(keywords, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call"); return 1; } if (PyObject_HasAttrString(obj, "starargs")) { int res; tmp = PyObject_GetAttrString(obj, "starargs"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &starargs, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { starargs = NULL; } if (PyObject_HasAttrString(obj, "kwargs")) { int res; tmp = PyObject_GetAttrString(obj, "kwargs"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &kwargs, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { kwargs = NULL; } *out = Call(func, args, keywords, starargs, kwargs, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Repr_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Repr"); return 1; } *out = Repr(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Num_type); if (isinstance == -1) { return 1; } if (isinstance) { object n; if (PyObject_HasAttrString(obj, "n")) { int res; tmp = PyObject_GetAttrString(obj, "n"); if (tmp == NULL) goto failed; res = obj2ast_object(tmp, &n, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"n\" missing from Num"); return 1; } *out = Num(n, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Str_type); if (isinstance == -1) { return 1; } if (isinstance) { string s; int has_b; if (PyObject_HasAttrString(obj, "s")) { int res; tmp = PyObject_GetAttrString(obj, "s"); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &s, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"s\" missing from Str"); return 1; } if (PyObject_HasAttrString(obj, "has_b")) { int res; tmp = PyObject_GetAttrString(obj, "has_b"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &has_b, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { has_b = 0; } *out = Str(s, has_b, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Attribute_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; identifier attr; expr_context_ty ctx; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute"); return 1; } if (PyObject_HasAttrString(obj, "attr")) { int res; tmp = PyObject_GetAttrString(obj, "attr"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &attr, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute"); return 1; } if (PyObject_HasAttrString(obj, "ctx")) { int res; tmp = PyObject_GetAttrString(obj, "ctx"); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute"); return 1; } *out = Attribute(value, attr, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Subscript_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; slice_ty slice; expr_context_ty ctx; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript"); return 1; } if (PyObject_HasAttrString(obj, "slice")) { int res; tmp = PyObject_GetAttrString(obj, "slice"); if (tmp == NULL) goto failed; res = obj2ast_slice(tmp, &slice, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript"); return 1; } if (PyObject_HasAttrString(obj, "ctx")) { int res; tmp = PyObject_GetAttrString(obj, "ctx"); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript"); return 1; } *out = Subscript(value, slice, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Name_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier id; expr_context_ty ctx; if (PyObject_HasAttrString(obj, "id")) { int res; tmp = PyObject_GetAttrString(obj, "id"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &id, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name"); return 1; } if (PyObject_HasAttrString(obj, "ctx")) { int res; tmp = PyObject_GetAttrString(obj, "ctx"); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name"); return 1; } *out = Name(id, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)List_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; expr_context_ty ctx; if (PyObject_HasAttrString(obj, "elts")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "elts"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(elts, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List"); return 1; } if (PyObject_HasAttrString(obj, "ctx")) { int res; tmp = PyObject_GetAttrString(obj, "ctx"); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List"); return 1; } *out = List(elts, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Tuple_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; expr_context_ty ctx; if (PyObject_HasAttrString(obj, "elts")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "elts"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(elts, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple"); return 1; } if (PyObject_HasAttrString(obj, "ctx")) { int res; tmp = PyObject_GetAttrString(obj, "ctx"); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple"); return 1; } *out = Tuple(elts, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Load_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Load; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Store_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Store; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Del_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Del; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)AugLoad_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = AugLoad; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)AugStore_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = AugStore; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Param_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Param; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Ellipsis_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Ellipsis(arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Slice_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty lower; expr_ty upper; expr_ty step; if (PyObject_HasAttrString(obj, "lower")) { int res; tmp = PyObject_GetAttrString(obj, "lower"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &lower, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { lower = NULL; } if (PyObject_HasAttrString(obj, "upper")) { int res; tmp = PyObject_GetAttrString(obj, "upper"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &upper, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { upper = NULL; } if (PyObject_HasAttrString(obj, "step")) { int res; tmp = PyObject_GetAttrString(obj, "step"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &step, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { step = NULL; } *out = Slice(lower, upper, step, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ExtSlice_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* dims; if (PyObject_HasAttrString(obj, "dims")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "dims"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ExtSlice field \"dims\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); dims = asdl_seq_new(len, arena); if (dims == NULL) goto failed; for (i = 0; i < len; i++) { slice_ty value; res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(dims, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"dims\" missing from ExtSlice"); return 1; } *out = ExtSlice(dims, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Index_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Index"); return 1; } *out = Index(value, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)And_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = And; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Or_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Or; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Add_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Add; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Sub_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Sub; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Mult_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Mult; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Div_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Div; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Mod_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Mod; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Pow_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Pow; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)LShift_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = LShift; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)RShift_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = RShift; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitOr_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitOr; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitXor_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitXor; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitAnd_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitAnd; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)FloorDiv_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = FloorDiv; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Invert_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Invert; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Not_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Not; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)UAdd_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = UAdd; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)USub_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = USub; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Eq_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Eq; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)NotEq_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = NotEq; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Lt_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Lt; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)LtE_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = LtE; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Gt_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Gt; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)GtE_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = GtE; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Is_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Is; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)IsNot_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = IsNot; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)In_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = In; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)NotIn_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = NotIn; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena) { PyObject* tmp = NULL; expr_ty target; expr_ty iter; asdl_seq* ifs; if (PyObject_HasAttrString(obj, "target")) { int res; tmp = PyObject_GetAttrString(obj, "target"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension"); return 1; } if (PyObject_HasAttrString(obj, "iter")) { int res; tmp = PyObject_GetAttrString(obj, "iter"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &iter, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension"); return 1; } if (PyObject_HasAttrString(obj, "ifs")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "ifs"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); ifs = asdl_seq_new(len, arena); if (ifs == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(ifs, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension"); return 1; } *out = comprehension(target, iter, ifs, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (PyObject_HasAttrString(obj, "lineno")) { int res; tmp = PyObject_GetAttrString(obj, "lineno"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler"); return 1; } if (PyObject_HasAttrString(obj, "col_offset")) { int res; tmp = PyObject_GetAttrString(obj, "col_offset"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)ExceptHandler_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty type; expr_ty name; asdl_seq* body; if (PyObject_HasAttrString(obj, "type")) { int res; tmp = PyObject_GetAttrString(obj, "type"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &type, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { type = NULL; } if (PyObject_HasAttrString(obj, "name")) { int res; tmp = PyObject_GetAttrString(obj, "name"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &name, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { name = NULL; } if (PyObject_HasAttrString(obj, "body")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "body"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(body, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler"); return 1; } *out = ExceptHandler(type, name, body, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena) { PyObject* tmp = NULL; asdl_seq* args; identifier vararg; identifier kwarg; asdl_seq* defaults; asdl_seq* type_comments; if (PyObject_HasAttrString(obj, "args")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "args"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); args = asdl_seq_new(len, arena); if (args == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(args, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments"); return 1; } if (PyObject_HasAttrString(obj, "vararg")) { int res; tmp = PyObject_GetAttrString(obj, "vararg"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &vararg, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { vararg = NULL; } if (PyObject_HasAttrString(obj, "kwarg")) { int res; tmp = PyObject_GetAttrString(obj, "kwarg"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &kwarg, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { kwarg = NULL; } if (PyObject_HasAttrString(obj, "defaults")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "defaults"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); defaults = asdl_seq_new(len, arena); if (defaults == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(defaults, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments"); return 1; } if (PyObject_HasAttrString(obj, "type_comments")) { int res; Py_ssize_t len; Py_ssize_t i; tmp = PyObject_GetAttrString(obj, "type_comments"); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"type_comments\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); type_comments = asdl_seq_new(len, arena); if (type_comments == NULL) goto failed; for (i = 0; i < len; i++) { string value; res = obj2ast_string(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; asdl_seq_SET(type_comments, i, value); } Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"type_comments\" missing from arguments"); return 1; } *out = arguments(args, vararg, kwarg, defaults, type_comments, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena) { PyObject* tmp = NULL; identifier arg; expr_ty value; if (PyObject_HasAttrString(obj, "arg")) { int res; tmp = PyObject_GetAttrString(obj, "arg"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &arg, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from keyword"); return 1; } if (PyObject_HasAttrString(obj, "value")) { int res; tmp = PyObject_GetAttrString(obj, "value"); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword"); return 1; } *out = keyword(arg, value, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena) { PyObject* tmp = NULL; identifier name; identifier asname; if (PyObject_HasAttrString(obj, "name")) { int res; tmp = PyObject_GetAttrString(obj, "name"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias"); return 1; } if (PyObject_HasAttrString(obj, "asname")) { int res; tmp = PyObject_GetAttrString(obj, "asname"); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &asname, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { asname = NULL; } *out = alias(name, asname, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena* arena) { PyObject* tmp = NULL; int isinstance; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)TypeIgnore_type); if (isinstance == -1) { return 1; } if (isinstance) { int lineno; if (PyObject_HasAttrString(obj, "lineno")) { int res; tmp = PyObject_GetAttrString(obj, "lineno"); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_XDECREF(tmp); tmp = NULL; } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore"); return 1; } *out = TypeIgnore(lineno, arena); if (*out == NULL) goto failed; return 0; } tmp = PyObject_Repr(obj); if (tmp == NULL) goto failed; PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %.400s", _PyUnicode_AsString(tmp)); failed: Py_XDECREF(tmp); return 1; } PyObject *ast27_parse(PyObject *self, PyObject *args); static PyMethodDef ast27_methods[] = { {"parse", ast27_parse, METH_VARARGS, "Parse string into typed AST."}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef _astmodule27 = { PyModuleDef_HEAD_INIT, "_ast27", NULL, 0, ast27_methods }; PyMODINIT_FUNC PyInit__ast27(void) { PyObject *m, *d; if (!init_types()) return NULL; m = PyModule_Create(&_astmodule27); if (!m) return NULL; d = PyModule_GetDict(m); if (PyDict_SetItemString(d, "AST", (PyObject*)&AST_type) < 0) return NULL; if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) return NULL; if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return NULL; if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0) return NULL; if (PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type) < 0) return NULL; if (PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) < 0) return NULL; if (PyDict_SetItemString(d, "FunctionType", (PyObject*)FunctionType_type) < 0) return NULL; if (PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return NULL; if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return NULL; if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0) return NULL; if (PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0) return NULL; if (PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) < 0) return NULL; if (PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return NULL; if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return NULL; if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return NULL; if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return NULL; if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return NULL; if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return NULL; if (PyDict_SetItemString(d, "TryExcept", (PyObject*)TryExcept_type) < 0) return NULL; if (PyDict_SetItemString(d, "TryFinally", (PyObject*)TryFinally_type) < 0) return NULL; if (PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0) return NULL; if (PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0) return NULL; if (PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) < 0) return NULL; if (PyDict_SetItemString(d, "Exec", (PyObject*)Exec_type) < 0) return NULL; if (PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0) return NULL; if (PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return NULL; if (PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return NULL; if (PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return NULL; if (PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0) return NULL; if (PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return NULL; if (PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0) return NULL; if (PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return NULL; if (PyDict_SetItemString(d, "Set", (PyObject*)Set_type) < 0) return NULL; if (PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "SetComp", (PyObject*)SetComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "DictComp", (PyObject*)DictComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "GeneratorExp", (PyObject*)GeneratorExp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return NULL; if (PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0) return NULL; if (PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return NULL; if (PyDict_SetItemString(d, "Repr", (PyObject*)Repr_type) < 0) return NULL; if (PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return NULL; if (PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return NULL; if (PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) < 0) return NULL; if (PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) < 0) return NULL; if (PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return NULL; if (PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return NULL; if (PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return NULL; if (PyDict_SetItemString(d, "expr_context", (PyObject*)expr_context_type) < 0) return NULL; if (PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return NULL; if (PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return NULL; if (PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0) return NULL; if (PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return NULL; if (PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return NULL; if (PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0) return NULL; if (PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return NULL; if (PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0) return NULL; if (PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return NULL; if (PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0) return NULL; if (PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return NULL; if (PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return NULL; if (PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0) return NULL; if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return NULL; if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return NULL; if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return NULL; if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return NULL; if (PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0) return NULL; if (PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0) return NULL; if (PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0) return NULL; if (PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0) return NULL; if (PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0) return NULL; if (PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return NULL; if (PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return NULL; if (PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return NULL; if (PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return NULL; if (PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return NULL; if (PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return NULL; if (PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return NULL; if (PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return NULL; if (PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return NULL; if (PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return NULL; if (PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return NULL; if (PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return NULL; if (PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return NULL; if (PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return NULL; if (PyDict_SetItemString(d, "comprehension", (PyObject*)comprehension_type) < 0) return NULL; if (PyDict_SetItemString(d, "excepthandler", (PyObject*)excepthandler_type) < 0) return NULL; if (PyDict_SetItemString(d, "ExceptHandler", (PyObject*)ExceptHandler_type) < 0) return NULL; if (PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) < 0) return NULL; if (PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0) return NULL; if (PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return NULL; if (PyDict_SetItemString(d, "type_ignore", (PyObject*)type_ignore_type) < 0) return NULL; if (PyDict_SetItemString(d, "TypeIgnore", (PyObject*)TypeIgnore_type) < 0) return NULL; return m; } PyObject* Ta27AST_mod2obj(mod_ty t) { init_types(); return ast2obj_mod(t); } /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */ mod_ty Ta27AST_obj2mod(PyObject* ast, PyArena* arena, int mode) { mod_ty res; PyObject *req_type[3]; char *req_name[3]; int isinstance; req_type[0] = (PyObject*)Module_type; req_type[1] = (PyObject*)Expression_type; req_type[2] = (PyObject*)Interactive_type; req_name[0] = "Module"; req_name[1] = "Expression"; req_name[2] = "Interactive"; assert(0 <= mode && mode <= 2); init_types(); isinstance = PyObject_IsInstance(ast, req_type[mode]); if (isinstance == -1) return NULL; if (!isinstance) { PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s", req_name[mode], Py_TYPE(ast)->tp_name); return NULL; } if (obj2ast_mod(ast, &res, arena) != 0) return NULL; else return res; } int Ta27AST_Check(PyObject* obj) { init_types(); return PyObject_IsInstance(obj, (PyObject*)&AST_type); } typed-ast-1.1.0/ast3/0000755€Tøžæ€2›s®0000000000013133476735015606 5ustar ddfisher00000000000000typed-ast-1.1.0/ast3/Custom/0000755€Tøžæ€2›s®0000000000013133476735017060 5ustar ddfisher00000000000000typed-ast-1.1.0/ast3/Custom/typed_ast.c0000644€Tøžæ€2›s®0000002224613133474673021225 0ustar ddfisher00000000000000#include "Python.h" #include "Python-ast.h" #include "compile.h" #include "node.h" #include "grammar.h" #include "token.h" #include "ast.h" #include "parsetok.h" #include "errcode.h" extern grammar _Ta3Parser_Grammar; /* from graminit.c */ // from Python/bltinmodule.c static const char * source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompilerFlags *cf, PyObject **cmd_copy) { const char *str; Py_ssize_t size; Py_buffer view; *cmd_copy = NULL; if (PyUnicode_Check(cmd)) { cf->cf_flags |= PyCF_IGNORE_COOKIE; str = PyUnicode_AsUTF8AndSize(cmd, &size); if (str == NULL) return NULL; } else if (PyBytes_Check(cmd)) { str = PyBytes_AS_STRING(cmd); size = PyBytes_GET_SIZE(cmd); } else if (PyByteArray_Check(cmd)) { str = PyByteArray_AS_STRING(cmd); size = PyByteArray_GET_SIZE(cmd); } else if (PyObject_GetBuffer(cmd, &view, PyBUF_SIMPLE) == 0) { /* Copy to NUL-terminated buffer. */ *cmd_copy = PyBytes_FromStringAndSize( (const char *)view.buf, view.len); PyBuffer_Release(&view); if (*cmd_copy == NULL) { return NULL; } str = PyBytes_AS_STRING(*cmd_copy); size = PyBytes_GET_SIZE(*cmd_copy); } else { PyErr_Format(PyExc_TypeError, "%s() arg 1 must be a %s object", funcname, what); return NULL; } if (strlen(str) != (size_t)size) { PyErr_SetString(PyExc_ValueError, "source code string cannot contain null bytes"); Py_CLEAR(*cmd_copy); return NULL; } return str; } // from Python/pythonrun.c /* compute parser flags based on compiler flags */ static int PARSER_FLAGS(PyCompilerFlags *flags) { int parser_flags = 0; if (!flags) return 0; if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT) parser_flags |= PyPARSE_DONT_IMPLY_DEDENT; if (flags->cf_flags & PyCF_IGNORE_COOKIE) parser_flags |= PyPARSE_IGNORE_COOKIE; if (flags->cf_flags & CO_FUTURE_BARRY_AS_BDFL) parser_flags |= PyPARSE_BARRY_AS_BDFL; return parser_flags; } // from Python/pythonrun.c /* Set the error appropriate to the given input error code (see errcode.h) */ static void err_input(perrdetail *err) { PyObject *v, *w, *errtype, *errtext; PyObject *msg_obj = NULL; char *msg = NULL; int offset = err->offset; errtype = PyExc_SyntaxError; switch (err->error) { case E_ERROR: return; case E_SYNTAX: errtype = PyExc_IndentationError; if (err->expected == INDENT) msg = "expected an indented block"; else if (err->token == INDENT) msg = "unexpected indent"; else if (err->token == DEDENT) msg = "unexpected unindent"; else { errtype = PyExc_SyntaxError; if (err->token == TYPE_COMMENT) msg = "misplaced type annotation"; else msg = "invalid syntax"; } break; case E_TOKEN: msg = "invalid token"; break; case E_EOFS: msg = "EOF while scanning triple-quoted string literal"; break; case E_EOLS: msg = "EOL while scanning string literal"; break; case E_INTR: if (!PyErr_Occurred()) PyErr_SetNone(PyExc_KeyboardInterrupt); goto cleanup; case E_NOMEM: PyErr_NoMemory(); goto cleanup; case E_EOF: msg = "unexpected EOF while parsing"; break; case E_TABSPACE: errtype = PyExc_TabError; msg = "inconsistent use of tabs and spaces in indentation"; break; case E_OVERFLOW: msg = "expression too long"; break; case E_DEDENT: errtype = PyExc_IndentationError; msg = "unindent does not match any outer indentation level"; break; case E_TOODEEP: errtype = PyExc_IndentationError; msg = "too many levels of indentation"; break; case E_DECODE: { PyObject *type, *value, *tb; PyErr_Fetch(&type, &value, &tb); msg = "unknown decode error"; if (value != NULL) msg_obj = PyObject_Str(value); Py_XDECREF(type); Py_XDECREF(value); Py_XDECREF(tb); break; } case E_LINECONT: msg = "unexpected character after line continuation character"; break; case E_IDENTIFIER: msg = "invalid character in identifier"; break; case E_BADSINGLE: msg = "multiple statements found while compiling a single statement"; break; default: fprintf(stderr, "error=%d\n", err->error); msg = "unknown parsing error"; break; } /* err->text may not be UTF-8 in case of decoding errors. Explicitly convert to an object. */ if (!err->text) { errtext = Py_None; Py_INCREF(Py_None); } else { errtext = PyUnicode_DecodeUTF8(err->text, err->offset, "replace"); if (errtext != NULL) { Py_ssize_t len = strlen(err->text); offset = (int)PyUnicode_GET_LENGTH(errtext); if (len != err->offset) { Py_DECREF(errtext); errtext = PyUnicode_DecodeUTF8(err->text, len, "replace"); } } } v = Py_BuildValue("(OiiN)", err->filename, err->lineno, offset, errtext); if (v != NULL) { if (msg_obj) w = Py_BuildValue("(OO)", msg_obj, v); else w = Py_BuildValue("(sO)", msg, v); } else w = NULL; Py_XDECREF(v); PyErr_SetObject(errtype, w); Py_XDECREF(w); cleanup: Py_XDECREF(msg_obj); if (err->text != NULL) { PyObject_FREE(err->text); err->text = NULL; } } // from Python/pythonrun.c static void err_free(perrdetail *err) { Py_CLEAR(err->filename); } // copy of PyParser_ASTFromStringObject in Python/pythonrun.c /* Preferred access to parser is through AST. */ mod_ty string_object_to_c_ast(const char *s, PyObject *filename, int start, PyCompilerFlags *flags, int feature_version, PyArena *arena) { mod_ty mod; PyCompilerFlags localflags; perrdetail err; int iflags = PARSER_FLAGS(flags); node *n = Ta3Parser_ParseStringObject(s, filename, &_Ta3Parser_Grammar, start, &err, &iflags); if (flags == NULL) { localflags.cf_flags = 0; flags = &localflags; } if (n) { flags->cf_flags |= iflags & PyCF_MASK; mod = Ta3AST_FromNodeObject(n, flags, filename, feature_version, arena); Ta3Node_Free(n); } else { err_input(&err); mod = NULL; } err_free(&err); return mod; } // adapted from Py_CompileStringObject in Python/pythonrun.c static PyObject * string_object_to_py_ast(const char *str, PyObject *filename, int start, PyCompilerFlags *flags, int feature_version) { mod_ty mod; PyObject *result; PyArena *arena = PyArena_New(); if (arena == NULL) return NULL; mod = string_object_to_c_ast(str, filename, start, flags, feature_version, arena); if (mod == NULL) { PyArena_Free(arena); return NULL; } result = Ta3AST_mod2obj(mod); PyArena_Free(arena); return result; } // adapted from builtin_compile_impl in Python/bltinmodule.c static PyObject * ast3_parse_impl(PyObject *source, PyObject *filename, const char *mode, int feature_version) { PyObject *source_copy; const char *str; int compile_mode = -1; PyCompilerFlags cf; int start[] = {Py_file_input, Py_eval_input, Py_single_input, Py_func_type_input}; PyObject *result; cf.cf_flags = PyCF_ONLY_AST | PyCF_SOURCE_IS_UTF8; if (strcmp(mode, "exec") == 0) compile_mode = 0; else if (strcmp(mode, "eval") == 0) compile_mode = 1; else if (strcmp(mode, "single") == 0) compile_mode = 2; else if (strcmp(mode, "func_type") == 0) compile_mode = 3; else { PyErr_SetString(PyExc_ValueError, "parse() mode must be 'exec', 'eval', 'single', for 'func_type'"); goto error; } str = source_as_string(source, "parse", "string or bytes", &cf, &source_copy); if (str == NULL) goto error; result = string_object_to_py_ast(str, filename, start[compile_mode], &cf, feature_version); Py_XDECREF(source_copy); goto finally; error: result = NULL; finally: Py_DECREF(filename); return result; } // adapted from builtin_compile in Python/clinic/bltinmodule.c.h PyObject * ast3_parse(PyObject *self, PyObject *args) { PyObject *return_value = NULL; PyObject *source; PyObject *filename; const char *mode; int feature_version; if (PyArg_ParseTuple(args, "OO&si:parse", &source, PyUnicode_FSDecoder, &filename, &mode, &feature_version)) return_value = ast3_parse_impl(source, filename, mode, feature_version); return return_value; } typed-ast-1.1.0/ast3/Include/0000755€Tøžæ€2›s®0000000000013133476735017171 5ustar ddfisher00000000000000typed-ast-1.1.0/ast3/Include/asdl.h0000644€Tøžæ€2›s®0000000230213050212017020235 0ustar ddfisher00000000000000#ifndef Ta3_ASDL_H #define Ta3_ASDL_H typedef PyObject * identifier; typedef PyObject * string; typedef PyObject * bytes; typedef PyObject * object; typedef PyObject * singleton; typedef PyObject * constant; /* It would be nice if the code generated by asdl_c.py was completely independent of Python, but it is a goal the requires too much work at this stage. So, for example, I'll represent identifiers as interned Python strings. */ /* XXX A sequence should be typed so that its use can be typechecked. */ typedef struct { Py_ssize_t size; void *elements[1]; } asdl_seq; typedef struct { Py_ssize_t size; int elements[1]; } asdl_int_seq; asdl_seq *_Ta3_asdl_seq_new(Py_ssize_t size, PyArena *arena); asdl_int_seq *_Ta3_asdl_int_seq_new(Py_ssize_t size, PyArena *arena); #define asdl_seq_GET(S, I) (S)->elements[(I)] #define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size) #ifdef Py_DEBUG #define asdl_seq_SET(S, I, V) \ do { \ Py_ssize_t _asdl_i = (I); \ assert((S) != NULL); \ assert(_asdl_i < (S)->size); \ (S)->elements[_asdl_i] = (V); \ } while (0) #else #define asdl_seq_SET(S, I, V) (S)->elements[I] = (V) #endif #endif /* !Ta3_ASDL_H */ typed-ast-1.1.0/ast3/Include/ast.h0000644€Tøžæ€2›s®0000000100613050212017020101 0ustar ddfisher00000000000000#ifndef Ta3_AST_H #define Ta3_AST_H #ifdef __cplusplus extern "C" { #endif extern int Ta3AST_Validate(mod_ty); extern mod_ty Ta3AST_FromNode( const node *n, PyCompilerFlags *flags, const char *filename, /* decoded from the filesystem encoding */ int feature_version, PyArena *arena); extern mod_ty Ta3AST_FromNodeObject( const node *n, PyCompilerFlags *flags, PyObject *filename, int feature_version, PyArena *arena); #ifdef __cplusplus } #endif #endif /* !Ta3_AST_H */ typed-ast-1.1.0/ast3/Include/bitset.h0000644€Tøžæ€2›s®0000000143313050212017020610 0ustar ddfisher00000000000000 #ifndef Ta3_BITSET_H #define Ta3_BITSET_H #ifdef __cplusplus extern "C" { #endif /* Bitset interface */ #define BYTE char typedef BYTE *bitset; bitset newbitset(int nbits); void delbitset(bitset bs); #define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0) int addbit(bitset bs, int ibit); /* Returns 0 if already set */ int samebitset(bitset bs1, bitset bs2, int nbits); void mergebitset(bitset bs1, bitset bs2, int nbits); #define BITSPERBYTE (8*sizeof(BYTE)) #define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE) #define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE) #define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE) #define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit)) #define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE) #ifdef __cplusplus } #endif #endif /* !Ta3_BITSET_H */ typed-ast-1.1.0/ast3/Include/compile.h0000644€Tøžæ€2›s®0000000050613050212017020746 0ustar ddfisher00000000000000#ifndef Ta3_COMPILE_H #define Ta3_COMPILE_H /* These definitions must match corresponding definitions in graminit.h. There's code in compile.c that checks that they are the same. */ #define Py_single_input 256 #define Py_file_input 257 #define Py_eval_input 258 #define Py_func_type_input 342 #endif /* !Ta3_COMPILE_H */ typed-ast-1.1.0/ast3/Include/errcode.h0000644€Tøžæ€2›s®0000000273413050212017020746 0ustar ddfisher00000000000000#ifndef Ta3_ERRCODE_H #define Ta3_ERRCODE_H #ifdef __cplusplus extern "C" { #endif /* Error codes passed around between file input, tokenizer, parser and interpreter. This is necessary so we can turn them into Python exceptions at a higher level. Note that some errors have a slightly different meaning when passed from the tokenizer to the parser than when passed from the parser to the interpreter; e.g. the parser only returns E_EOF when it hits EOF immediately, and it never returns E_OK. */ #define E_OK 10 /* No error */ #define E_EOF 11 /* End Of File */ #define E_INTR 12 /* Interrupted */ #define E_TOKEN 13 /* Bad token */ #define E_SYNTAX 14 /* Syntax error */ #define E_NOMEM 15 /* Ran out of memory */ #define E_DONE 16 /* Parsing complete */ #define E_ERROR 17 /* Execution error */ #define E_TABSPACE 18 /* Inconsistent mixing of tabs and spaces */ #define E_OVERFLOW 19 /* Node had too many children */ #define E_TOODEEP 20 /* Too many indentation levels */ #define E_DEDENT 21 /* No matching outer block for dedent */ #define E_DECODE 22 /* Error in decoding into Unicode */ #define E_EOFS 23 /* EOF in triple-quoted string */ #define E_EOLS 24 /* EOL in single-quoted string */ #define E_LINECONT 25 /* Unexpected characters after a line continuation */ #define E_IDENTIFIER 26 /* Invalid characters in identifier */ #define E_BADSINGLE 27 /* Ill-formed single statement input */ #ifdef __cplusplus } #endif #endif /* !Ta3_ERRCODE_H */ typed-ast-1.1.0/ast3/Include/graminit.h0000644€Tøžæ€2›s®0000000376513050212017021142 0ustar ddfisher00000000000000/* Generated by Parser/pgen */ #define single_input 256 #define file_input 257 #define eval_input 258 #define decorator 259 #define decorators 260 #define decorated 261 #define async_funcdef 262 #define funcdef 263 #define parameters 264 #define typedargslist 265 #define tfpdef 266 #define varargslist 267 #define vfpdef 268 #define stmt 269 #define simple_stmt 270 #define small_stmt 271 #define expr_stmt 272 #define annassign 273 #define testlist_star_expr 274 #define augassign 275 #define del_stmt 276 #define pass_stmt 277 #define flow_stmt 278 #define break_stmt 279 #define continue_stmt 280 #define return_stmt 281 #define yield_stmt 282 #define raise_stmt 283 #define import_stmt 284 #define import_name 285 #define import_from 286 #define import_as_name 287 #define dotted_as_name 288 #define import_as_names 289 #define dotted_as_names 290 #define dotted_name 291 #define global_stmt 292 #define nonlocal_stmt 293 #define assert_stmt 294 #define compound_stmt 295 #define async_stmt 296 #define if_stmt 297 #define while_stmt 298 #define for_stmt 299 #define try_stmt 300 #define with_stmt 301 #define with_item 302 #define except_clause 303 #define suite 304 #define test 305 #define test_nocond 306 #define lambdef 307 #define lambdef_nocond 308 #define or_test 309 #define and_test 310 #define not_test 311 #define comparison 312 #define comp_op 313 #define star_expr 314 #define expr 315 #define xor_expr 316 #define and_expr 317 #define shift_expr 318 #define arith_expr 319 #define term 320 #define factor 321 #define power 322 #define atom_expr 323 #define atom 324 #define testlist_comp 325 #define trailer 326 #define subscriptlist 327 #define subscript 328 #define sliceop 329 #define exprlist 330 #define testlist 331 #define dictorsetmaker 332 #define classdef 333 #define arglist 334 #define argument 335 #define comp_iter 336 #define comp_for 337 #define comp_if 338 #define encoding_decl 339 #define yield_expr 340 #define yield_arg 341 #define func_type_input 342 #define func_type 343 #define typelist 344 typed-ast-1.1.0/ast3/Include/grammar.h0000644€Tøžæ€2›s®0000000404113050212017020742 0ustar ddfisher00000000000000 /* Grammar interface */ #ifndef Ta3_GRAMMAR_H #define Ta3_GRAMMAR_H #ifdef __cplusplus extern "C" { #endif #include "bitset.h" /* Sigh... */ /* A label of an arc */ typedef struct { int lb_type; char *lb_str; } label; #define EMPTY 0 /* Label number 0 is by definition the empty label */ /* A list of labels */ typedef struct { int ll_nlabels; label *ll_label; } labellist; /* An arc from one state to another */ typedef struct { short a_lbl; /* Label of this arc */ short a_arrow; /* State where this arc goes to */ } arc; /* A state in a DFA */ typedef struct { int s_narcs; arc *s_arc; /* Array of arcs */ /* Optional accelerators */ int s_lower; /* Lowest label index */ int s_upper; /* Highest label index */ int *s_accel; /* Accelerator */ int s_accept; /* Nonzero for accepting state */ } state; /* A DFA */ typedef struct { int d_type; /* Non-terminal this represents */ char *d_name; /* For printing */ int d_initial; /* Initial state */ int d_nstates; state *d_state; /* Array of states */ bitset d_first; } dfa; /* A grammar */ typedef struct { int g_ndfas; dfa *g_dfa; /* Array of DFAs */ labellist g_ll; int g_start; /* Start symbol of the grammar */ int g_accel; /* Set if accelerators present */ } grammar; /* FUNCTIONS */ grammar *newgrammar(int start); void freegrammar(grammar *g); dfa *adddfa(grammar *g, int type, const char *name); int addstate(dfa *d); void addarc(dfa *d, int from, int to, int lbl); dfa *Ta3Grammar_FindDFA(grammar *g, int type); int addlabel(labellist *ll, int type, const char *str); int findlabel(labellist *ll, int type, const char *str); const char *Ta3Grammar_LabelRepr(label *lb); void translatelabels(grammar *g); void addfirstsets(grammar *g); void Ta3Grammar_AddAccelerators(grammar *g); void Ta3Grammar_RemoveAccelerators(grammar *); void printgrammar(grammar *g, FILE *fp); void printnonterminals(grammar *g, FILE *fp); #ifdef __cplusplus } #endif #endif /* !Ta3_GRAMMAR_H */ typed-ast-1.1.0/ast3/Include/node.h0000644€Tøžæ€2›s®0000000173413050212017020247 0ustar ddfisher00000000000000 /* Parse tree node interface */ #ifndef Ta3_NODE_H #define Ta3_NODE_H #ifdef __cplusplus extern "C" { #endif typedef struct _node { short n_type; char *n_str; int n_lineno; int n_col_offset; int n_nchildren; struct _node *n_child; } node; extern node *Ta3Node_New(int type); extern int Ta3Node_AddChild(node *n, int type, char *str, int lineno, int col_offset); extern void Ta3Node_Free(node *n); #ifndef Py_LIMITED_API extern Py_ssize_t _Ta3Node_SizeOf(node *n); #endif /* Node access functions */ #define NCH(n) ((n)->n_nchildren) #define CHILD(n, i) (&(n)->n_child[i]) #define RCHILD(n, i) (CHILD(n, NCH(n) + i)) #define TYPE(n) ((n)->n_type) #define STR(n) ((n)->n_str) #define LINENO(n) ((n)->n_lineno) /* Assert that the type of a node is what we expect */ #define REQ(n, type) assert(TYPE(n) == (type)) extern void PyNode_ListTree(node *); #ifdef __cplusplus } #endif #endif /* !Ta3_NODE_H */ typed-ast-1.1.0/ast3/Include/parsetok.h0000644€Tøžæ€2›s®0000000544413050212017021154 0ustar ddfisher00000000000000 /* Parser-tokenizer link interface */ #ifndef Py_LIMITED_API #ifndef Ta3_PARSETOK_H #define Ta3_PARSETOK_H #ifdef __cplusplus extern "C" { #endif typedef struct { int error; #ifndef PGEN /* The filename is useless for pgen, see comment in tok_state structure */ PyObject *filename; #endif int lineno; int offset; char *text; /* UTF-8-encoded string */ int token; int expected; } perrdetail; #if 0 #define PyPARSE_YIELD_IS_KEYWORD 0x0001 #endif #define PyPARSE_DONT_IMPLY_DEDENT 0x0002 #if 0 #define PyPARSE_WITH_IS_KEYWORD 0x0003 #define PyPARSE_PRINT_IS_FUNCTION 0x0004 #define PyPARSE_UNICODE_LITERALS 0x0008 #endif #define PyPARSE_IGNORE_COOKIE 0x0010 #define PyPARSE_BARRY_AS_BDFL 0x0020 extern node * Ta3Parser_ParseString(const char *, grammar *, int, perrdetail *); extern node * Ta3Parser_ParseFile (FILE *, const char *, grammar *, int, const char *, const char *, perrdetail *); extern node * Ta3Parser_ParseStringFlags(const char *, grammar *, int, perrdetail *, int); extern node * Ta3Parser_ParseFileFlags( FILE *fp, const char *filename, /* decoded from the filesystem encoding */ const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int flags); extern node * Ta3Parser_ParseFileFlagsEx( FILE *fp, const char *filename, /* decoded from the filesystem encoding */ const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int *flags); extern node * Ta3Parser_ParseFileObject( FILE *fp, PyObject *filename, const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int *flags); extern node * Ta3Parser_ParseStringFlagsFilename( const char *s, const char *filename, /* decoded from the filesystem encoding */ grammar *g, int start, perrdetail *err_ret, int flags); extern node * Ta3Parser_ParseStringFlagsFilenameEx( const char *s, const char *filename, /* decoded from the filesystem encoding */ grammar *g, int start, perrdetail *err_ret, int *flags); extern node * Ta3Parser_ParseStringObject( const char *s, PyObject *filename, grammar *g, int start, perrdetail *err_ret, int *flags); /* Note that the following functions are defined in pythonrun.c, not in parsetok.c */ PyAPI_FUNC(void) PyParser_SetError(perrdetail *); PyAPI_FUNC(void) PyParser_ClearError(perrdetail *); #ifdef __cplusplus } #endif #endif /* !Ta3_PARSETOK_H */ #endif /* !Py_LIMITED_API */ typed-ast-1.1.0/ast3/Include/Python-ast.h0000644€Tøžæ€2›s®0000005630413050212017021373 0ustar ddfisher00000000000000/* File automatically generated by Parser/asdl_c.py. */ #include "asdl.h" typedef struct _mod *mod_ty; typedef struct _stmt *stmt_ty; typedef struct _expr *expr_ty; typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5, Param=6 } expr_context_ty; typedef struct _slice *slice_ty; typedef enum _boolop { And=1, Or=2 } boolop_ty; typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7, LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12, FloorDiv=13 } operator_ty; typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty; typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8, In=9, NotIn=10 } cmpop_ty; typedef struct _comprehension *comprehension_ty; typedef struct _excepthandler *excepthandler_ty; typedef struct _arguments *arguments_ty; typedef struct _arg *arg_ty; typedef struct _keyword *keyword_ty; typedef struct _alias *alias_ty; typedef struct _withitem *withitem_ty; typedef struct _type_ignore *type_ignore_ty; enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, FunctionType_kind=4, Suite_kind=5}; struct _mod { enum _mod_kind kind; union { struct { asdl_seq *body; asdl_seq *type_ignores; } Module; struct { asdl_seq *body; } Interactive; struct { expr_ty body; } Expression; struct { asdl_seq *argtypes; expr_ty returns; } FunctionType; struct { asdl_seq *body; } Suite; } v; }; enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3, Return_kind=4, Delete_kind=5, Assign_kind=6, AugAssign_kind=7, AnnAssign_kind=8, For_kind=9, AsyncFor_kind=10, While_kind=11, If_kind=12, With_kind=13, AsyncWith_kind=14, Raise_kind=15, Try_kind=16, Assert_kind=17, Import_kind=18, ImportFrom_kind=19, Global_kind=20, Nonlocal_kind=21, Expr_kind=22, Pass_kind=23, Break_kind=24, Continue_kind=25}; struct _stmt { enum _stmt_kind kind; union { struct { identifier name; arguments_ty args; asdl_seq *body; asdl_seq *decorator_list; expr_ty returns; string type_comment; } FunctionDef; struct { identifier name; arguments_ty args; asdl_seq *body; asdl_seq *decorator_list; expr_ty returns; string type_comment; } AsyncFunctionDef; struct { identifier name; asdl_seq *bases; asdl_seq *keywords; asdl_seq *body; asdl_seq *decorator_list; } ClassDef; struct { expr_ty value; } Return; struct { asdl_seq *targets; } Delete; struct { asdl_seq *targets; expr_ty value; string type_comment; } Assign; struct { expr_ty target; operator_ty op; expr_ty value; } AugAssign; struct { expr_ty target; expr_ty annotation; expr_ty value; int simple; } AnnAssign; struct { expr_ty target; expr_ty iter; asdl_seq *body; asdl_seq *orelse; string type_comment; } For; struct { expr_ty target; expr_ty iter; asdl_seq *body; asdl_seq *orelse; string type_comment; } AsyncFor; struct { expr_ty test; asdl_seq *body; asdl_seq *orelse; } While; struct { expr_ty test; asdl_seq *body; asdl_seq *orelse; } If; struct { asdl_seq *items; asdl_seq *body; string type_comment; } With; struct { asdl_seq *items; asdl_seq *body; string type_comment; } AsyncWith; struct { expr_ty exc; expr_ty cause; } Raise; struct { asdl_seq *body; asdl_seq *handlers; asdl_seq *orelse; asdl_seq *finalbody; } Try; struct { expr_ty test; expr_ty msg; } Assert; struct { asdl_seq *names; } Import; struct { identifier module; asdl_seq *names; int level; } ImportFrom; struct { asdl_seq *names; } Global; struct { asdl_seq *names; } Nonlocal; struct { expr_ty value; } Expr; } v; int lineno; int col_offset; }; enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4, IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8, SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11, Await_kind=12, Yield_kind=13, YieldFrom_kind=14, Compare_kind=15, Call_kind=16, Num_kind=17, Str_kind=18, FormattedValue_kind=19, JoinedStr_kind=20, Bytes_kind=21, NameConstant_kind=22, Ellipsis_kind=23, Constant_kind=24, Attribute_kind=25, Subscript_kind=26, Starred_kind=27, Name_kind=28, List_kind=29, Tuple_kind=30}; struct _expr { enum _expr_kind kind; union { struct { boolop_ty op; asdl_seq *values; } BoolOp; struct { expr_ty left; operator_ty op; expr_ty right; } BinOp; struct { unaryop_ty op; expr_ty operand; } UnaryOp; struct { arguments_ty args; expr_ty body; } Lambda; struct { expr_ty test; expr_ty body; expr_ty orelse; } IfExp; struct { asdl_seq *keys; asdl_seq *values; } Dict; struct { asdl_seq *elts; } Set; struct { expr_ty elt; asdl_seq *generators; } ListComp; struct { expr_ty elt; asdl_seq *generators; } SetComp; struct { expr_ty key; expr_ty value; asdl_seq *generators; } DictComp; struct { expr_ty elt; asdl_seq *generators; } GeneratorExp; struct { expr_ty value; } Await; struct { expr_ty value; } Yield; struct { expr_ty value; } YieldFrom; struct { expr_ty left; asdl_int_seq *ops; asdl_seq *comparators; } Compare; struct { expr_ty func; asdl_seq *args; asdl_seq *keywords; } Call; struct { object n; } Num; struct { string s; } Str; struct { expr_ty value; int conversion; expr_ty format_spec; } FormattedValue; struct { asdl_seq *values; } JoinedStr; struct { bytes s; } Bytes; struct { singleton value; } NameConstant; struct { constant value; } Constant; struct { expr_ty value; identifier attr; expr_context_ty ctx; } Attribute; struct { expr_ty value; slice_ty slice; expr_context_ty ctx; } Subscript; struct { expr_ty value; expr_context_ty ctx; } Starred; struct { identifier id; expr_context_ty ctx; } Name; struct { asdl_seq *elts; expr_context_ty ctx; } List; struct { asdl_seq *elts; expr_context_ty ctx; } Tuple; } v; int lineno; int col_offset; }; enum _slice_kind {Slice_kind=1, ExtSlice_kind=2, Index_kind=3}; struct _slice { enum _slice_kind kind; union { struct { expr_ty lower; expr_ty upper; expr_ty step; } Slice; struct { asdl_seq *dims; } ExtSlice; struct { expr_ty value; } Index; } v; }; struct _comprehension { expr_ty target; expr_ty iter; asdl_seq *ifs; int is_async; }; enum _excepthandler_kind {ExceptHandler_kind=1}; struct _excepthandler { enum _excepthandler_kind kind; union { struct { expr_ty type; identifier name; asdl_seq *body; } ExceptHandler; } v; int lineno; int col_offset; }; struct _arguments { asdl_seq *args; arg_ty vararg; asdl_seq *kwonlyargs; asdl_seq *kw_defaults; arg_ty kwarg; asdl_seq *defaults; }; struct _arg { identifier arg; expr_ty annotation; string type_comment; int lineno; int col_offset; }; struct _keyword { identifier arg; expr_ty value; }; struct _alias { identifier name; identifier asname; }; struct _withitem { expr_ty context_expr; expr_ty optional_vars; }; enum _type_ignore_kind {TypeIgnore_kind=1}; struct _type_ignore { enum _type_ignore_kind kind; union { struct { int lineno; } TypeIgnore; } v; }; #define Module(a0, a1, a2) _Ta3_Module(a0, a1, a2) mod_ty _Ta3_Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena); #define Interactive(a0, a1) _Ta3_Interactive(a0, a1) mod_ty _Ta3_Interactive(asdl_seq * body, PyArena *arena); #define Expression(a0, a1) _Ta3_Expression(a0, a1) mod_ty _Ta3_Expression(expr_ty body, PyArena *arena); #define FunctionType(a0, a1, a2) _Ta3_FunctionType(a0, a1, a2) mod_ty _Ta3_FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena); #define Suite(a0, a1) _Ta3_Suite(a0, a1) mod_ty _Ta3_Suite(asdl_seq * body, PyArena *arena); #define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8) _Ta3_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8) stmt_ty _Ta3_FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, expr_ty returns, string type_comment, int lineno, int col_offset, PyArena *arena); #define AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8) _Ta3_AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8) stmt_ty _Ta3_AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, expr_ty returns, string type_comment, int lineno, int col_offset, PyArena *arena); #define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) _Ta3_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Ta3_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq * body, asdl_seq * decorator_list, int lineno, int col_offset, PyArena *arena); #define Return(a0, a1, a2, a3) _Ta3_Return(a0, a1, a2, a3) stmt_ty _Ta3_Return(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Delete(a0, a1, a2, a3) _Ta3_Delete(a0, a1, a2, a3) stmt_ty _Ta3_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena); #define Assign(a0, a1, a2, a3, a4, a5) _Ta3_Assign(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int col_offset, PyArena *arena); #define AugAssign(a0, a1, a2, a3, a4, a5) _Ta3_AugAssign(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int col_offset, PyArena *arena); #define AnnAssign(a0, a1, a2, a3, a4, a5, a6) _Ta3_AnnAssign(a0, a1, a2, a3, a4, a5, a6) stmt_ty _Ta3_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple, int lineno, int col_offset, PyArena *arena); #define For(a0, a1, a2, a3, a4, a5, a6, a7) _Ta3_For(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Ta3_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena); #define AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7) _Ta3_AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Ta3_AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena); #define While(a0, a1, a2, a3, a4, a5) _Ta3_While(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena); #define If(a0, a1, a2, a3, a4, a5) _Ta3_If(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena); #define With(a0, a1, a2, a3, a4, a5) _Ta3_With(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena); #define AsyncWith(a0, a1, a2, a3, a4, a5) _Ta3_AsyncWith(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena); #define Raise(a0, a1, a2, a3, a4) _Ta3_Raise(a0, a1, a2, a3, a4) stmt_ty _Ta3_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, PyArena *arena); #define Try(a0, a1, a2, a3, a4, a5, a6) _Ta3_Try(a0, a1, a2, a3, a4, a5, a6) stmt_ty _Ta3_Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, asdl_seq * finalbody, int lineno, int col_offset, PyArena *arena); #define Assert(a0, a1, a2, a3, a4) _Ta3_Assert(a0, a1, a2, a3, a4) stmt_ty _Ta3_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena); #define Import(a0, a1, a2, a3) _Ta3_Import(a0, a1, a2, a3) stmt_ty _Ta3_Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena); #define ImportFrom(a0, a1, a2, a3, a4, a5) _Ta3_ImportFrom(a0, a1, a2, a3, a4, a5) stmt_ty _Ta3_ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int col_offset, PyArena *arena); #define Global(a0, a1, a2, a3) _Ta3_Global(a0, a1, a2, a3) stmt_ty _Ta3_Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena); #define Nonlocal(a0, a1, a2, a3) _Ta3_Nonlocal(a0, a1, a2, a3) stmt_ty _Ta3_Nonlocal(asdl_seq * names, int lineno, int col_offset, PyArena *arena); #define Expr(a0, a1, a2, a3) _Ta3_Expr(a0, a1, a2, a3) stmt_ty _Ta3_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Pass(a0, a1, a2) _Ta3_Pass(a0, a1, a2) stmt_ty _Ta3_Pass(int lineno, int col_offset, PyArena *arena); #define Break(a0, a1, a2) _Ta3_Break(a0, a1, a2) stmt_ty _Ta3_Break(int lineno, int col_offset, PyArena *arena); #define Continue(a0, a1, a2) _Ta3_Continue(a0, a1, a2) stmt_ty _Ta3_Continue(int lineno, int col_offset, PyArena *arena); #define BoolOp(a0, a1, a2, a3, a4) _Ta3_BoolOp(a0, a1, a2, a3, a4) expr_ty _Ta3_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena *arena); #define BinOp(a0, a1, a2, a3, a4, a5) _Ta3_BinOp(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset, PyArena *arena); #define UnaryOp(a0, a1, a2, a3, a4) _Ta3_UnaryOp(a0, a1, a2, a3, a4) expr_ty _Ta3_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena *arena); #define Lambda(a0, a1, a2, a3, a4) _Ta3_Lambda(a0, a1, a2, a3, a4) expr_ty _Ta3_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena *arena); #define IfExp(a0, a1, a2, a3, a4, a5) _Ta3_IfExp(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset, PyArena *arena); #define Dict(a0, a1, a2, a3, a4) _Ta3_Dict(a0, a1, a2, a3, a4) expr_ty _Ta3_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena *arena); #define Set(a0, a1, a2, a3) _Ta3_Set(a0, a1, a2, a3) expr_ty _Ta3_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena); #define ListComp(a0, a1, a2, a3, a4) _Ta3_ListComp(a0, a1, a2, a3, a4) expr_ty _Ta3_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define SetComp(a0, a1, a2, a3, a4) _Ta3_SetComp(a0, a1, a2, a3, a4) expr_ty _Ta3_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define DictComp(a0, a1, a2, a3, a4, a5) _Ta3_DictComp(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define GeneratorExp(a0, a1, a2, a3, a4) _Ta3_GeneratorExp(a0, a1, a2, a3, a4) expr_ty _Ta3_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena); #define Await(a0, a1, a2, a3) _Ta3_Await(a0, a1, a2, a3) expr_ty _Ta3_Await(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Yield(a0, a1, a2, a3) _Ta3_Yield(a0, a1, a2, a3) expr_ty _Ta3_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena); #define YieldFrom(a0, a1, a2, a3) _Ta3_YieldFrom(a0, a1, a2, a3) expr_ty _Ta3_YieldFrom(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Compare(a0, a1, a2, a3, a4, a5) _Ta3_Compare(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, int col_offset, PyArena *arena); #define Call(a0, a1, a2, a3, a4, a5) _Ta3_Call(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int col_offset, PyArena *arena); #define Num(a0, a1, a2, a3) _Ta3_Num(a0, a1, a2, a3) expr_ty _Ta3_Num(object n, int lineno, int col_offset, PyArena *arena); #define Str(a0, a1, a2, a3) _Ta3_Str(a0, a1, a2, a3) expr_ty _Ta3_Str(string s, int lineno, int col_offset, PyArena *arena); #define FormattedValue(a0, a1, a2, a3, a4, a5) _Ta3_FormattedValue(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno, int col_offset, PyArena *arena); #define JoinedStr(a0, a1, a2, a3) _Ta3_JoinedStr(a0, a1, a2, a3) expr_ty _Ta3_JoinedStr(asdl_seq * values, int lineno, int col_offset, PyArena *arena); #define Bytes(a0, a1, a2, a3) _Ta3_Bytes(a0, a1, a2, a3) expr_ty _Ta3_Bytes(bytes s, int lineno, int col_offset, PyArena *arena); #define NameConstant(a0, a1, a2, a3) _Ta3_NameConstant(a0, a1, a2, a3) expr_ty _Ta3_NameConstant(singleton value, int lineno, int col_offset, PyArena *arena); #define Ellipsis(a0, a1, a2) _Ta3_Ellipsis(a0, a1, a2) expr_ty _Ta3_Ellipsis(int lineno, int col_offset, PyArena *arena); #define Constant(a0, a1, a2, a3) _Ta3_Constant(a0, a1, a2, a3) expr_ty _Ta3_Constant(constant value, int lineno, int col_offset, PyArena *arena); #define Attribute(a0, a1, a2, a3, a4, a5) _Ta3_Attribute(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Subscript(a0, a1, a2, a3, a4, a5) _Ta3_Subscript(a0, a1, a2, a3, a4, a5) expr_ty _Ta3_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Starred(a0, a1, a2, a3, a4) _Ta3_Starred(a0, a1, a2, a3, a4) expr_ty _Ta3_Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Name(a0, a1, a2, a3, a4) _Ta3_Name(a0, a1, a2, a3, a4) expr_ty _Ta3_Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define List(a0, a1, a2, a3, a4) _Ta3_List(a0, a1, a2, a3, a4) expr_ty _Ta3_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Tuple(a0, a1, a2, a3, a4) _Ta3_Tuple(a0, a1, a2, a3, a4) expr_ty _Ta3_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena); #define Slice(a0, a1, a2, a3) _Ta3_Slice(a0, a1, a2, a3) slice_ty _Ta3_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena); #define ExtSlice(a0, a1) _Ta3_ExtSlice(a0, a1) slice_ty _Ta3_ExtSlice(asdl_seq * dims, PyArena *arena); #define Index(a0, a1) _Ta3_Index(a0, a1) slice_ty _Ta3_Index(expr_ty value, PyArena *arena); #define comprehension(a0, a1, a2, a3, a4) _Ta3_comprehension(a0, a1, a2, a3, a4) comprehension_ty _Ta3_comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, int is_async, PyArena *arena); #define ExceptHandler(a0, a1, a2, a3, a4, a5) _Ta3_ExceptHandler(a0, a1, a2, a3, a4, a5) excepthandler_ty _Ta3_ExceptHandler(expr_ty type, identifier name, asdl_seq * body, int lineno, int col_offset, PyArena *arena); #define arguments(a0, a1, a2, a3, a4, a5, a6) _Ta3_arguments(a0, a1, a2, a3, a4, a5, a6) arguments_ty _Ta3_arguments(asdl_seq * args, arg_ty vararg, asdl_seq * kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, asdl_seq * defaults, PyArena *arena); #define arg(a0, a1, a2, a3, a4, a5) _Ta3_arg(a0, a1, a2, a3, a4, a5) arg_ty _Ta3_arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int col_offset, PyArena *arena); #define keyword(a0, a1, a2) _Ta3_keyword(a0, a1, a2) keyword_ty _Ta3_keyword(identifier arg, expr_ty value, PyArena *arena); #define alias(a0, a1, a2) _Ta3_alias(a0, a1, a2) alias_ty _Ta3_alias(identifier name, identifier asname, PyArena *arena); #define withitem(a0, a1, a2) _Ta3_withitem(a0, a1, a2) withitem_ty _Ta3_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena); #define TypeIgnore(a0, a1) _Ta3_TypeIgnore(a0, a1) type_ignore_ty _Ta3_TypeIgnore(int lineno, PyArena *arena); PyObject* Ta3AST_mod2obj(mod_ty t); mod_ty Ta3AST_obj2mod(PyObject* ast, PyArena* arena, int mode); int Ta3AST_Check(PyObject* obj); typed-ast-1.1.0/ast3/Include/token.h0000644€Tøžæ€2›s®0000000367113050212017020444 0ustar ddfisher00000000000000 /* Token types */ #ifndef Py_LIMITED_API #ifndef Ta3_TOKEN_H #define Ta3_TOKEN_H #ifdef __cplusplus extern "C" { #endif #undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */ #define ENDMARKER 0 #define NAME 1 #define NUMBER 2 #define STRING 3 #define NEWLINE 4 #define INDENT 5 #define DEDENT 6 #define LPAR 7 #define RPAR 8 #define LSQB 9 #define RSQB 10 #define COLON 11 #define COMMA 12 #define SEMI 13 #define PLUS 14 #define MINUS 15 #define STAR 16 #define SLASH 17 #define VBAR 18 #define AMPER 19 #define LESS 20 #define GREATER 21 #define EQUAL 22 #define DOT 23 #define PERCENT 24 #define LBRACE 25 #define RBRACE 26 #define EQEQUAL 27 #define NOTEQUAL 28 #define LESSEQUAL 29 #define GREATEREQUAL 30 #define TILDE 31 #define CIRCUMFLEX 32 #define LEFTSHIFT 33 #define RIGHTSHIFT 34 #define DOUBLESTAR 35 #define PLUSEQUAL 36 #define MINEQUAL 37 #define STAREQUAL 38 #define SLASHEQUAL 39 #define PERCENTEQUAL 40 #define AMPEREQUAL 41 #define VBAREQUAL 42 #define CIRCUMFLEXEQUAL 43 #define LEFTSHIFTEQUAL 44 #define RIGHTSHIFTEQUAL 45 #define DOUBLESTAREQUAL 46 #define DOUBLESLASH 47 #define DOUBLESLASHEQUAL 48 #define AT 49 #define ATEQUAL 50 #define RARROW 51 #define ELLIPSIS 52 /* Don't forget to update the table _Ta3Parser_TokenNames in tokenizer.c! */ #define OP 53 #define AWAIT 54 #define ASYNC 55 #define TYPE_IGNORE 56 #define TYPE_COMMENT 57 #define ERRORTOKEN 58 #define N_TOKENS 59 /* Special definitions for cooperation with parser */ #define NT_OFFSET 256 #define ISTERMINAL(x) ((x) < NT_OFFSET) #define ISNONTERMINAL(x) ((x) >= NT_OFFSET) #define ISEOF(x) ((x) == ENDMARKER) extern const char *_Ta3Parser_TokenNames[]; /* Token names */ extern int Ta3Token_OneChar(int); extern int Ta3Token_TwoChars(int, int); extern int Ta3Token_ThreeChars(int, int, int); #ifdef __cplusplus } #endif #endif /* !Ta3_TOKEN_H */ #endif /* Py_LIMITED_API */ typed-ast-1.1.0/ast3/Parser/0000755€Tøžæ€2›s®0000000000013133476735017042 5ustar ddfisher00000000000000typed-ast-1.1.0/ast3/Parser/acceler.c0000644€Tøžæ€2›s®0000000643513050212017020567 0ustar ddfisher00000000000000 /* Parser accelerator module */ /* The parser as originally conceived had disappointing performance. This module does some precomputation that speeds up the selection of a DFA based upon a token, turning a search through an array into a simple indexing operation. The parser now cannot work without the accelerators installed. Note that the accelerators are installed dynamically when the parser is initialized, they are not part of the static data structure written on graminit.[ch] by the parser generator. */ #include "pgenheaders.h" #include "grammar.h" #include "node.h" #include "token.h" #include "parser.h" /* Forward references */ static void fixdfa(grammar *, dfa *); static void fixstate(grammar *, state *); void Ta3Grammar_AddAccelerators(grammar *g) { dfa *d; int i; d = g->g_dfa; for (i = g->g_ndfas; --i >= 0; d++) fixdfa(g, d); g->g_accel = 1; } void Ta3Grammar_RemoveAccelerators(grammar *g) { dfa *d; int i; g->g_accel = 0; d = g->g_dfa; for (i = g->g_ndfas; --i >= 0; d++) { state *s; int j; s = d->d_state; for (j = 0; j < d->d_nstates; j++, s++) { if (s->s_accel) PyObject_FREE(s->s_accel); s->s_accel = NULL; } } } static void fixdfa(grammar *g, dfa *d) { state *s; int j; s = d->d_state; for (j = 0; j < d->d_nstates; j++, s++) fixstate(g, s); } static void fixstate(grammar *g, state *s) { arc *a; int k; int *accel; int nl = g->g_ll.ll_nlabels; s->s_accept = 0; accel = (int *) PyObject_MALLOC(nl * sizeof(int)); if (accel == NULL) { fprintf(stderr, "no mem to build parser accelerators\n"); exit(1); } for (k = 0; k < nl; k++) accel[k] = -1; a = s->s_arc; for (k = s->s_narcs; --k >= 0; a++) { int lbl = a->a_lbl; label *l = &g->g_ll.ll_label[lbl]; int type = l->lb_type; if (a->a_arrow >= (1 << 7)) { printf("XXX too many states!\n"); continue; } if (ISNONTERMINAL(type)) { dfa *d1 = Ta3Grammar_FindDFA(g, type); int ibit; if (type - NT_OFFSET >= (1 << 7)) { printf("XXX too high nonterminal number!\n"); continue; } for (ibit = 0; ibit < g->g_ll.ll_nlabels; ibit++) { if (testbit(d1->d_first, ibit)) { if (accel[ibit] != -1) printf("XXX ambiguity!\n"); accel[ibit] = a->a_arrow | (1 << 7) | ((type - NT_OFFSET) << 8); } } } else if (lbl == EMPTY) s->s_accept = 1; else if (lbl >= 0 && lbl < nl) accel[lbl] = a->a_arrow; } while (nl > 0 && accel[nl-1] == -1) nl--; for (k = 0; k < nl && accel[k] == -1;) k++; if (k < nl) { int i; s->s_accel = (int *) PyObject_MALLOC((nl-k) * sizeof(int)); if (s->s_accel == NULL) { fprintf(stderr, "no mem to add parser accelerators\n"); exit(1); } s->s_lower = k; s->s_upper = nl; for (i = 0; k < nl; i++, k++) s->s_accel[i] = accel[k]; } PyObject_FREE(accel); } typed-ast-1.1.0/ast3/Parser/bitset.c0000644€Tøžæ€2›s®0000000205113050212017020451 0ustar ddfisher00000000000000 /* Bitset primitives used by the parser generator */ #include "pgenheaders.h" #include "bitset.h" bitset newbitset(int nbits) { int nbytes = NBYTES(nbits); bitset ss = (char *)PyObject_MALLOC(sizeof(BYTE) * nbytes); if (ss == NULL) Py_FatalError("no mem for bitset"); ss += nbytes; while (--nbytes >= 0) *--ss = 0; return ss; } void delbitset(bitset ss) { PyObject_FREE(ss); } int addbit(bitset ss, int ibit) { int ibyte = BIT2BYTE(ibit); BYTE mask = BIT2MASK(ibit); if (ss[ibyte] & mask) return 0; /* Bit already set */ ss[ibyte] |= mask; return 1; } #if 0 /* Now a macro */ int testbit(bitset ss, int ibit) { return (ss[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0; } #endif int samebitset(bitset ss1, bitset ss2, int nbits) { int i; for (i = NBYTES(nbits); --i >= 0; ) if (*ss1++ != *ss2++) return 0; return 1; } void mergebitset(bitset ss1, bitset ss2, int nbits) { int i; for (i = NBYTES(nbits); --i >= 0; ) *ss1++ |= *ss2++; } typed-ast-1.1.0/ast3/Parser/grammar.c0000644€Tøžæ€2›s®0000001672013050212017020615 0ustar ddfisher00000000000000 /* Grammar implementation */ #include "Python.h" #include "pgenheaders.h" #include #include "token.h" #include "grammar.h" PyAPI_DATA(int) Py_DebugFlag; grammar * newgrammar(int start) { grammar *g; g = (grammar *)PyObject_MALLOC(sizeof(grammar)); if (g == NULL) Py_FatalError("no mem for new grammar"); g->g_ndfas = 0; g->g_dfa = NULL; g->g_start = start; g->g_ll.ll_nlabels = 0; g->g_ll.ll_label = NULL; g->g_accel = 0; return g; } void freegrammar(grammar *g) { int i, j; for (i = 0; i < g->g_ndfas; i++) { free(g->g_dfa[i].d_name); for (j = 0; j < g->g_dfa[i].d_nstates; j++) PyObject_FREE(g->g_dfa[i].d_state[j].s_arc); PyObject_FREE(g->g_dfa[i].d_state); } PyObject_FREE(g->g_dfa); for (i = 0; i < g->g_ll.ll_nlabels; i++) free(g->g_ll.ll_label[i].lb_str); PyObject_FREE(g->g_ll.ll_label); PyObject_FREE(g); } dfa * adddfa(grammar *g, int type, const char *name) { dfa *d; g->g_dfa = (dfa *)PyObject_REALLOC(g->g_dfa, sizeof(dfa) * (g->g_ndfas + 1)); if (g->g_dfa == NULL) Py_FatalError("no mem to resize dfa in adddfa"); d = &g->g_dfa[g->g_ndfas++]; d->d_type = type; d->d_name = strdup(name); d->d_nstates = 0; d->d_state = NULL; d->d_initial = -1; d->d_first = NULL; return d; /* Only use while fresh! */ } int addstate(dfa *d) { state *s; d->d_state = (state *)PyObject_REALLOC(d->d_state, sizeof(state) * (d->d_nstates + 1)); if (d->d_state == NULL) Py_FatalError("no mem to resize state in addstate"); s = &d->d_state[d->d_nstates++]; s->s_narcs = 0; s->s_arc = NULL; s->s_lower = 0; s->s_upper = 0; s->s_accel = NULL; s->s_accept = 0; return Py_SAFE_DOWNCAST(s - d->d_state, intptr_t, int); } void addarc(dfa *d, int from, int to, int lbl) { state *s; arc *a; assert(0 <= from && from < d->d_nstates); assert(0 <= to && to < d->d_nstates); s = &d->d_state[from]; s->s_arc = (arc *)PyObject_REALLOC(s->s_arc, sizeof(arc) * (s->s_narcs + 1)); if (s->s_arc == NULL) Py_FatalError("no mem to resize arc list in addarc"); a = &s->s_arc[s->s_narcs++]; a->a_lbl = lbl; a->a_arrow = to; } int addlabel(labellist *ll, int type, const char *str) { int i; label *lb; for (i = 0; i < ll->ll_nlabels; i++) { if (ll->ll_label[i].lb_type == type && strcmp(ll->ll_label[i].lb_str, str) == 0) return i; } ll->ll_label = (label *)PyObject_REALLOC(ll->ll_label, sizeof(label) * (ll->ll_nlabels + 1)); if (ll->ll_label == NULL) Py_FatalError("no mem to resize labellist in addlabel"); lb = &ll->ll_label[ll->ll_nlabels++]; lb->lb_type = type; lb->lb_str = strdup(str); if (Py_DebugFlag) printf("Label @ %8p, %d: %s\n", ll, ll->ll_nlabels, Ta3Grammar_LabelRepr(lb)); return Py_SAFE_DOWNCAST(lb - ll->ll_label, intptr_t, int); } /* Same, but rather dies than adds */ int findlabel(labellist *ll, int type, const char *str) { int i; for (i = 0; i < ll->ll_nlabels; i++) { if (ll->ll_label[i].lb_type == type /*&& strcmp(ll->ll_label[i].lb_str, str) == 0*/) return i; } fprintf(stderr, "Label %d/'%s' not found\n", type, str); Py_FatalError("grammar.c:findlabel()"); /* Py_FatalError() is declared with __attribute__((__noreturn__)). GCC emits a warning without "return 0;" (compiler bug!), but Clang is smarter and emits a warning on the return... */ #ifndef __clang__ return 0; /* Make gcc -Wall happy */ #endif } /* Forward */ static void translabel(grammar *, label *); void translatelabels(grammar *g) { int i; #ifdef Py_DEBUG printf("Translating labels ...\n"); #endif /* Don't translate EMPTY */ for (i = EMPTY+1; i < g->g_ll.ll_nlabels; i++) translabel(g, &g->g_ll.ll_label[i]); } static void translabel(grammar *g, label *lb) { int i; if (Py_DebugFlag) printf("Translating label %s ...\n", Ta3Grammar_LabelRepr(lb)); if (lb->lb_type == NAME) { for (i = 0; i < g->g_ndfas; i++) { if (strcmp(lb->lb_str, g->g_dfa[i].d_name) == 0) { if (Py_DebugFlag) printf( "Label %s is non-terminal %d.\n", lb->lb_str, g->g_dfa[i].d_type); lb->lb_type = g->g_dfa[i].d_type; free(lb->lb_str); lb->lb_str = NULL; return; } } for (i = 0; i < (int)N_TOKENS; i++) { if (strcmp(lb->lb_str, _Ta3Parser_TokenNames[i]) == 0) { if (Py_DebugFlag) printf("Label %s is terminal %d.\n", lb->lb_str, i); lb->lb_type = i; free(lb->lb_str); lb->lb_str = NULL; return; } } printf("Can't translate NAME label '%s'\n", lb->lb_str); return; } if (lb->lb_type == STRING) { if (isalpha(Py_CHARMASK(lb->lb_str[1])) || lb->lb_str[1] == '_') { char *p; char *src; char *dest; size_t name_len; if (Py_DebugFlag) printf("Label %s is a keyword\n", lb->lb_str); lb->lb_type = NAME; src = lb->lb_str + 1; p = strchr(src, '\''); if (p) name_len = p - src; else name_len = strlen(src); dest = (char *)malloc(name_len + 1); if (!dest) { printf("Can't alloc dest '%s'\n", src); return; } strncpy(dest, src, name_len); dest[name_len] = '\0'; free(lb->lb_str); lb->lb_str = dest; } else if (lb->lb_str[2] == lb->lb_str[0]) { int type = (int) Ta3Token_OneChar(lb->lb_str[1]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else if (lb->lb_str[2] && lb->lb_str[3] == lb->lb_str[0]) { int type = (int) Ta3Token_TwoChars(lb->lb_str[1], lb->lb_str[2]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else if (lb->lb_str[2] && lb->lb_str[3] && lb->lb_str[4] == lb->lb_str[0]) { int type = (int) Ta3Token_ThreeChars(lb->lb_str[1], lb->lb_str[2], lb->lb_str[3]); if (type != OP) { lb->lb_type = type; free(lb->lb_str); lb->lb_str = NULL; } else printf("Unknown OP label %s\n", lb->lb_str); } else printf("Can't translate STRING label %s\n", lb->lb_str); } else printf("Can't translate label '%s'\n", Ta3Grammar_LabelRepr(lb)); } typed-ast-1.1.0/ast3/Parser/grammar1.c0000644€Tøžæ€2›s®0000000242413050212017020672 0ustar ddfisher00000000000000 /* Grammar subroutines needed by parser */ #include "Python.h" #include "pgenheaders.h" #include "grammar.h" #include "token.h" /* Return the DFA for the given type */ dfa * Ta3Grammar_FindDFA(grammar *g, int type) { dfa *d; #if 1 /* Massive speed-up */ d = &g->g_dfa[type - NT_OFFSET]; assert(d->d_type == type); return d; #else /* Old, slow version */ int i; for (i = g->g_ndfas, d = g->g_dfa; --i >= 0; d++) { if (d->d_type == type) return d; } assert(0); /* NOTREACHED */ #endif } const char * Ta3Grammar_LabelRepr(label *lb) { static char buf[100]; if (lb->lb_type == ENDMARKER) return "EMPTY"; else if (ISNONTERMINAL(lb->lb_type)) { if (lb->lb_str == NULL) { PyOS_snprintf(buf, sizeof(buf), "NT%d", lb->lb_type); return buf; } else return lb->lb_str; } else if (lb->lb_type < N_TOKENS) { if (lb->lb_str == NULL) return _Ta3Parser_TokenNames[lb->lb_type]; else { PyOS_snprintf(buf, sizeof(buf), "%.32s(%.32s)", _Ta3Parser_TokenNames[lb->lb_type], lb->lb_str); return buf; } } else { Py_FatalError("invalid label"); return NULL; } } typed-ast-1.1.0/ast3/Parser/node.c0000644€Tøžæ€2›s®0000001070013050212017020104 0ustar ddfisher00000000000000/* Parse tree node implementation */ #include "Python.h" #include "node.h" #include "errcode.h" node * Ta3Node_New(int type) { node *n = (node *) PyObject_MALLOC(1 * sizeof(node)); if (n == NULL) return NULL; n->n_type = type; n->n_str = NULL; n->n_lineno = 0; n->n_nchildren = 0; n->n_child = NULL; return n; } /* See comments at XXXROUNDUP below. Returns -1 on overflow. */ static int fancy_roundup(int n) { /* Round up to the closest power of 2 >= n. */ int result = 256; assert(n > 128); while (result < n) { result <<= 1; if (result <= 0) return -1; } return result; } /* A gimmick to make massive numbers of reallocs quicker. The result is * a number >= the input. In Ta3Node_AddChild, it's used like so, when * we're about to add child number current_size + 1: * * if XXXROUNDUP(current_size) < XXXROUNDUP(current_size + 1): * allocate space for XXXROUNDUP(current_size + 1) total children * else: * we already have enough space * * Since a node starts out empty, we must have * * XXXROUNDUP(0) < XXXROUNDUP(1) * * so that we allocate space for the first child. One-child nodes are very * common (presumably that would change if we used a more abstract form * of syntax tree), so to avoid wasting memory it's desirable that * XXXROUNDUP(1) == 1. That in turn forces XXXROUNDUP(0) == 0. * * Else for 2 <= n <= 128, we round up to the closest multiple of 4. Why 4? * Rounding up to a multiple of an exact power of 2 is very efficient, and * most nodes with more than one child have <= 4 kids. * * Else we call fancy_roundup() to grow proportionately to n. We've got an * extreme case then (like test_longexp.py), and on many platforms doing * anything less than proportional growth leads to exorbitant runtime * (e.g., MacPython), or extreme fragmentation of user address space (e.g., * Win98). * * In a run of compileall across the 2.3a0 Lib directory, Andrew MacIntyre * reported that, with this scheme, 89% of PyObject_REALLOC calls in * Ta3Node_AddChild passed 1 for the size, and 9% passed 4. So this usually * wastes very little memory, but is very effective at sidestepping * platform-realloc disasters on vulnerable platforms. * * Note that this would be straightforward if a node stored its current * capacity. The code is tricky to avoid that. */ #define XXXROUNDUP(n) ((n) <= 1 ? (n) : \ (n) <= 128 ? (int)_Py_SIZE_ROUND_UP((n), 4) : \ fancy_roundup(n)) int Ta3Node_AddChild(node *n1, int type, char *str, int lineno, int col_offset) { const int nch = n1->n_nchildren; int current_capacity; int required_capacity; node *n; if (nch == INT_MAX || nch < 0) return E_OVERFLOW; current_capacity = XXXROUNDUP(nch); required_capacity = XXXROUNDUP(nch + 1); if (current_capacity < 0 || required_capacity < 0) return E_OVERFLOW; if (current_capacity < required_capacity) { if ((size_t)required_capacity > SIZE_MAX / sizeof(node)) { return E_NOMEM; } n = n1->n_child; n = (node *) PyObject_REALLOC(n, required_capacity * sizeof(node)); if (n == NULL) return E_NOMEM; n1->n_child = n; } n = &n1->n_child[n1->n_nchildren++]; n->n_type = type; n->n_str = str; n->n_lineno = lineno; n->n_col_offset = col_offset; n->n_nchildren = 0; n->n_child = NULL; return 0; } /* Forward */ static void freechildren(node *); static Py_ssize_t sizeofchildren(node *n); void Ta3Node_Free(node *n) { if (n != NULL) { freechildren(n); PyObject_FREE(n); } } Py_ssize_t _Ta3Node_SizeOf(node *n) { Py_ssize_t res = 0; if (n != NULL) res = sizeof(node) + sizeofchildren(n); return res; } static void freechildren(node *n) { int i; for (i = NCH(n); --i >= 0; ) freechildren(CHILD(n, i)); if (n->n_child != NULL) PyObject_FREE(n->n_child); if (STR(n) != NULL) PyObject_FREE(STR(n)); } static Py_ssize_t sizeofchildren(node *n) { Py_ssize_t res = 0; int i; for (i = NCH(n); --i >= 0; ) res += sizeofchildren(CHILD(n, i)); if (n->n_child != NULL) /* allocated size of n->n_child array */ res += XXXROUNDUP(NCH(n)) * sizeof(node); if (STR(n) != NULL) res += strlen(STR(n)) + 1; return res; } typed-ast-1.1.0/ast3/Parser/parser.c0000644€Tøžæ€2›s®0000002712213050212017020461 0ustar ddfisher00000000000000 /* Parser implementation */ /* For a description, see the comments at end of this file */ /* XXX To do: error recovery */ #include "Python.h" #include "pgenheaders.h" #include "token.h" #include "grammar.h" #include "node.h" #include "parser.h" #include "errcode.h" #ifdef Py_DEBUG extern int Py_DebugFlag; #define D(x) if (!Py_DebugFlag); else x #else #define D(x) #endif /* STACK DATA TYPE */ static void s_reset(stack *); static void s_reset(stack *s) { s->s_top = &s->s_base[MAXSTACK]; } #define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK]) static int s_push(stack *s, dfa *d, node *parent) { stackentry *top; if (s->s_top == s->s_base) { fprintf(stderr, "s_push: parser stack overflow\n"); return E_NOMEM; } top = --s->s_top; top->s_dfa = d; top->s_parent = parent; top->s_state = 0; return 0; } #ifdef Py_DEBUG static void s_pop(stack *s) { if (s_empty(s)) Py_FatalError("s_pop: parser stack underflow -- FATAL"); s->s_top++; } #else /* !Py_DEBUG */ #define s_pop(s) (s)->s_top++ #endif /* PARSER CREATION */ parser_state * Ta3Parser_New(grammar *g, int start) { parser_state *ps; if (!g->g_accel) Ta3Grammar_AddAccelerators(g); ps = (parser_state *)PyMem_MALLOC(sizeof(parser_state)); if (ps == NULL) return NULL; ps->p_grammar = g; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD ps->p_flags = 0; #endif ps->p_tree = Ta3Node_New(start); if (ps->p_tree == NULL) { PyMem_FREE(ps); return NULL; } s_reset(&ps->p_stack); (void) s_push(&ps->p_stack, Ta3Grammar_FindDFA(g, start), ps->p_tree); return ps; } void Ta3Parser_Delete(parser_state *ps) { /* NB If you want to save the parse tree, you must set p_tree to NULL before calling delparser! */ Ta3Node_Free(ps->p_tree); PyMem_FREE(ps); } /* PARSER STACK OPERATIONS */ static int shift(stack *s, int type, char *str, int newstate, int lineno, int col_offset) { int err; assert(!s_empty(s)); err = Ta3Node_AddChild(s->s_top->s_parent, type, str, lineno, col_offset); if (err) return err; s->s_top->s_state = newstate; return 0; } static int push(stack *s, int type, dfa *d, int newstate, int lineno, int col_offset) { int err; node *n; n = s->s_top->s_parent; assert(!s_empty(s)); err = Ta3Node_AddChild(n, type, (char *)NULL, lineno, col_offset); if (err) return err; s->s_top->s_state = newstate; return s_push(s, d, CHILD(n, NCH(n)-1)); } /* PARSER PROPER */ static int classify(parser_state *ps, int type, const char *str) { grammar *g = ps->p_grammar; int n = g->g_ll.ll_nlabels; if (type == NAME) { label *l = g->g_ll.ll_label; int i; for (i = n; i > 0; i--, l++) { if (l->lb_type != NAME || l->lb_str == NULL || l->lb_str[0] != str[0] || strcmp(l->lb_str, str) != 0) continue; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #if 0 /* Leaving this in as an example */ if (!(ps->p_flags & CO_FUTURE_WITH_STATEMENT)) { if (str[0] == 'w' && strcmp(str, "with") == 0) break; /* not a keyword yet */ else if (str[0] == 'a' && strcmp(str, "as") == 0) break; /* not a keyword yet */ } #endif #endif D(printf("It's a keyword\n")); return n - i; } } { label *l = g->g_ll.ll_label; int i; for (i = n; i > 0; i--, l++) { if (l->lb_type == type && l->lb_str == NULL) { D(printf("It's a token we know\n")); return n - i; } } } D(printf("Illegal token\n")); return -1; } #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #if 0 /* Leaving this in as an example */ static void future_hack(parser_state *ps) { node *n = ps->p_stack.s_top->s_parent; node *ch, *cch; int i; /* from __future__ import ..., must have at least 4 children */ n = CHILD(n, 0); if (NCH(n) < 4) return; ch = CHILD(n, 0); if (STR(ch) == NULL || strcmp(STR(ch), "from") != 0) return; ch = CHILD(n, 1); if (NCH(ch) == 1 && STR(CHILD(ch, 0)) && strcmp(STR(CHILD(ch, 0)), "__future__") != 0) return; ch = CHILD(n, 3); /* ch can be a star, a parenthesis or import_as_names */ if (TYPE(ch) == STAR) return; if (TYPE(ch) == LPAR) ch = CHILD(n, 4); for (i = 0; i < NCH(ch); i += 2) { cch = CHILD(ch, i); if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME) { char *str_ch = STR(CHILD(cch, 0)); if (strcmp(str_ch, FUTURE_WITH_STATEMENT) == 0) { ps->p_flags |= CO_FUTURE_WITH_STATEMENT; } else if (strcmp(str_ch, FUTURE_PRINT_FUNCTION) == 0) { ps->p_flags |= CO_FUTURE_PRINT_FUNCTION; } else if (strcmp(str_ch, FUTURE_UNICODE_LITERALS) == 0) { ps->p_flags |= CO_FUTURE_UNICODE_LITERALS; } } } } #endif #endif /* future keyword */ int Ta3Parser_AddToken(parser_state *ps, int type, char *str, int lineno, int col_offset, int *expected_ret) { int ilabel; int err; D(printf("Token %s/'%s' ... ", _Ta3Parser_TokenNames[type], str)); /* Find out which label this token is */ ilabel = classify(ps, type, str); if (ilabel < 0) return E_SYNTAX; /* Loop until the token is shifted or an error occurred */ for (;;) { /* Fetch the current dfa and state */ dfa *d = ps->p_stack.s_top->s_dfa; state *s = &d->d_state[ps->p_stack.s_top->s_state]; D(printf(" DFA '%s', state %d:", d->d_name, ps->p_stack.s_top->s_state)); /* Check accelerator */ if (s->s_lower <= ilabel && ilabel < s->s_upper) { int x = s->s_accel[ilabel - s->s_lower]; if (x != -1) { if (x & (1<<7)) { /* Push non-terminal */ int nt = (x >> 8) + NT_OFFSET; int arrow = x & ((1<<7)-1); dfa *d1 = Ta3Grammar_FindDFA( ps->p_grammar, nt); if ((err = push(&ps->p_stack, nt, d1, arrow, lineno, col_offset)) > 0) { D(printf(" MemError: push\n")); return err; } D(printf(" Push ...\n")); continue; } /* Shift the token */ if ((err = shift(&ps->p_stack, type, str, x, lineno, col_offset)) > 0) { D(printf(" MemError: shift.\n")); return err; } D(printf(" Shift.\n")); /* Pop while we are in an accept-only state */ while (s = &d->d_state [ps->p_stack.s_top->s_state], s->s_accept && s->s_narcs == 1) { D(printf(" DFA '%s', state %d: " "Direct pop.\n", d->d_name, ps->p_stack.s_top->s_state)); #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #if 0 if (d->d_name[0] == 'i' && strcmp(d->d_name, "import_stmt") == 0) future_hack(ps); #endif #endif s_pop(&ps->p_stack); if (s_empty(&ps->p_stack)) { D(printf(" ACCEPT.\n")); return E_DONE; } d = ps->p_stack.s_top->s_dfa; } return E_OK; } } if (s->s_accept) { #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #if 0 if (d->d_name[0] == 'i' && strcmp(d->d_name, "import_stmt") == 0) future_hack(ps); #endif #endif /* Pop this dfa and try again */ s_pop(&ps->p_stack); D(printf(" Pop ...\n")); if (s_empty(&ps->p_stack)) { D(printf(" Error: bottom of stack.\n")); return E_SYNTAX; } continue; } /* Stuck, report syntax error */ D(printf(" Error.\n")); if (expected_ret) { if (s->s_lower == s->s_upper - 1) { /* Only one possible expected token */ *expected_ret = ps->p_grammar-> g_ll.ll_label[s->s_lower].lb_type; } else *expected_ret = -1; } return E_SYNTAX; } } #ifdef Py_DEBUG /* DEBUG OUTPUT */ void dumptree(grammar *g, node *n) { int i; if (n == NULL) printf("NIL"); else { label l; l.lb_type = TYPE(n); l.lb_str = STR(n); printf("%s", Ta3Grammar_LabelRepr(&l)); if (ISNONTERMINAL(TYPE(n))) { printf("("); for (i = 0; i < NCH(n); i++) { if (i > 0) printf(","); dumptree(g, CHILD(n, i)); } printf(")"); } } } void showtree(grammar *g, node *n) { int i; if (n == NULL) return; if (ISNONTERMINAL(TYPE(n))) { for (i = 0; i < NCH(n); i++) showtree(g, CHILD(n, i)); } else if (ISTERMINAL(TYPE(n))) { printf("%s", _Ta3Parser_TokenNames[TYPE(n)]); if (TYPE(n) == NUMBER || TYPE(n) == NAME) printf("(%s)", STR(n)); printf(" "); } else printf("? "); } void printtree(parser_state *ps) { if (Py_DebugFlag) { printf("Parse tree:\n"); dumptree(ps->p_grammar, ps->p_tree); printf("\n"); printf("Tokens:\n"); showtree(ps->p_grammar, ps->p_tree); printf("\n"); } printf("Listing:\n"); PyNode_ListTree(ps->p_tree); printf("\n"); } #endif /* Py_DEBUG */ /* Description ----------- The parser's interface is different than usual: the function addtoken() must be called for each token in the input. This makes it possible to turn it into an incremental parsing system later. The parsing system constructs a parse tree as it goes. A parsing rule is represented as a Deterministic Finite-state Automaton (DFA). A node in a DFA represents a state of the parser; an arc represents a transition. Transitions are either labeled with terminal symbols or with non-terminals. When the parser decides to follow an arc labeled with a non-terminal, it is invoked recursively with the DFA representing the parsing rule for that as its initial state; when that DFA accepts, the parser that invoked it continues. The parse tree constructed by the recursively called parser is inserted as a child in the current parse tree. The DFA's can be constructed automatically from a more conventional language description. An extended LL(1) grammar (ELL(1)) is suitable. Certain restrictions make the parser's life easier: rules that can produce the empty string should be outlawed (there are other ways to put loops or optional parts in the language). To avoid the need to construct FIRST sets, we can require that all but the last alternative of a rule (really: arc going out of a DFA's state) must begin with a terminal symbol. As an example, consider this grammar: expr: term (OP term)* term: CONSTANT | '(' expr ')' The DFA corresponding to the rule for expr is: ------->.---term-->.-------> ^ | | | \----OP----/ The parse tree generated for the input a+b is: (expr: (term: (NAME: a)), (OP: +), (term: (NAME: b))) */ typed-ast-1.1.0/ast3/Parser/parser.h0000644€Tøžæ€2›s®0000000203113050212017020456 0ustar ddfisher00000000000000#ifndef Ta3_PARSER_H #define Ta3_PARSER_H #ifdef __cplusplus extern "C" { #endif /* Parser interface */ #define MAXSTACK 1500 typedef struct { int s_state; /* State in current DFA */ dfa *s_dfa; /* Current DFA */ struct _node *s_parent; /* Where to add next node */ } stackentry; typedef struct { stackentry *s_top; /* Top entry */ stackentry s_base[MAXSTACK];/* Array of stack entries */ /* NB The stack grows down */ } stack; typedef struct { stack p_stack; /* Stack of parser states */ grammar *p_grammar; /* Grammar to use */ node *p_tree; /* Top of parse tree */ #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD unsigned long p_flags; /* see co_flags in Include/code.h */ #endif } parser_state; parser_state *Ta3Parser_New(grammar *g, int start); void Ta3Parser_Delete(parser_state *ps); int Ta3Parser_AddToken(parser_state *ps, int type, char *str, int lineno, int col_offset, int *expected_ret); void Ta3Grammar_AddAccelerators(grammar *g); #ifdef __cplusplus } #endif #endif /* !Ta3_PARSER_H */ typed-ast-1.1.0/ast3/Parser/parsetok.c0000644€Tøžæ€2›s®0000003032713050212017021016 0ustar ddfisher00000000000000 /* Parser-tokenizer link implementation */ #include "pgenheaders.h" #include "tokenizer.h" #include "node.h" #include "grammar.h" #include "parser.h" #include "parsetok.h" #include "errcode.h" #include "graminit.h" /* Forward */ static node *parsetok(struct tok_state *, grammar *, int, perrdetail *, int *); static int initerr(perrdetail *err_ret, PyObject * filename); /* Parse input coming from a string. Return error code, print some errors. */ node * Ta3Parser_ParseString(const char *s, grammar *g, int start, perrdetail *err_ret) { return Ta3Parser_ParseStringFlagsFilename(s, NULL, g, start, err_ret, 0); } node * Ta3Parser_ParseStringFlags(const char *s, grammar *g, int start, perrdetail *err_ret, int flags) { return Ta3Parser_ParseStringFlagsFilename(s, NULL, g, start, err_ret, flags); } node * Ta3Parser_ParseStringFlagsFilename(const char *s, const char *filename, grammar *g, int start, perrdetail *err_ret, int flags) { int iflags = flags; return Ta3Parser_ParseStringFlagsFilenameEx(s, filename, g, start, err_ret, &iflags); } node * Ta3Parser_ParseStringObject(const char *s, PyObject *filename, grammar *g, int start, perrdetail *err_ret, int *flags) { struct tok_state *tok; int exec_input = start == file_input; if (initerr(err_ret, filename) < 0) return NULL; if (*flags & PyPARSE_IGNORE_COOKIE) tok = Ta3Tokenizer_FromUTF8(s, exec_input); else tok = Ta3Tokenizer_FromString(s, exec_input); if (tok == NULL) { err_ret->error = PyErr_Occurred() ? E_DECODE : E_NOMEM; return NULL; } #ifndef PGEN Py_INCREF(err_ret->filename); tok->filename = err_ret->filename; #endif return parsetok(tok, g, start, err_ret, flags); } node * Ta3Parser_ParseStringFlagsFilenameEx(const char *s, const char *filename_str, grammar *g, int start, perrdetail *err_ret, int *flags) { node *n; PyObject *filename = NULL; #ifndef PGEN if (filename_str != NULL) { filename = PyUnicode_DecodeFSDefault(filename_str); if (filename == NULL) { err_ret->error = E_ERROR; return NULL; } } #endif n = Ta3Parser_ParseStringObject(s, filename, g, start, err_ret, flags); #ifndef PGEN Py_XDECREF(filename); #endif return n; } /* Parse input coming from a file. Return error code, print some errors. */ node * Ta3Parser_ParseFile(FILE *fp, const char *filename, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret) { return Ta3Parser_ParseFileFlags(fp, filename, NULL, g, start, ps1, ps2, err_ret, 0); } node * Ta3Parser_ParseFileFlags(FILE *fp, const char *filename, const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int flags) { int iflags = flags; return Ta3Parser_ParseFileFlagsEx(fp, filename, enc, g, start, ps1, ps2, err_ret, &iflags); } node * Ta3Parser_ParseFileObject(FILE *fp, PyObject *filename, const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int *flags) { struct tok_state *tok; if (initerr(err_ret, filename) < 0) return NULL; if ((tok = Ta3Tokenizer_FromFile(fp, enc, ps1, ps2)) == NULL) { err_ret->error = E_NOMEM; return NULL; } #ifndef PGEN Py_INCREF(err_ret->filename); tok->filename = err_ret->filename; #endif return parsetok(tok, g, start, err_ret, flags); } node * Ta3Parser_ParseFileFlagsEx(FILE *fp, const char *filename, const char *enc, grammar *g, int start, const char *ps1, const char *ps2, perrdetail *err_ret, int *flags) { node *n; PyObject *fileobj = NULL; #ifndef PGEN if (filename != NULL) { fileobj = PyUnicode_DecodeFSDefault(filename); if (fileobj == NULL) { err_ret->error = E_ERROR; return NULL; } } #endif n = Ta3Parser_ParseFileObject(fp, fileobj, enc, g, start, ps1, ps2, err_ret, flags); #ifndef PGEN Py_XDECREF(fileobj); #endif return n; } #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD #if 0 static const char with_msg[] = "%s:%d: Warning: 'with' will become a reserved keyword in Python 2.6\n"; static const char as_msg[] = "%s:%d: Warning: 'as' will become a reserved keyword in Python 2.6\n"; static void warn(const char *msg, const char *filename, int lineno) { if (filename == NULL) filename = ""; PySys_WriteStderr(msg, filename, lineno); } #endif #endif typedef struct { int *items; size_t size; size_t num_items; } growable_int_array; int growable_int_array_init(growable_int_array *arr, size_t initial_size) { assert(initial_size > 0); arr->items = malloc(initial_size * sizeof(*arr->items)); arr->size = initial_size; arr->num_items = 0; return arr->items != NULL; } int growable_int_array_add(growable_int_array *arr, int item) { if (arr->num_items >= arr->size) { arr->size *= 2; arr->items = realloc(arr->items, arr->size * sizeof(*arr->items)); if (!arr->items) return 0; } arr->items[arr->num_items] = item; arr->num_items++; return 1; } void growable_int_array_deallocate(growable_int_array *arr) { free(arr->items); } /* Parse input coming from the given tokenizer structure. Return error code. */ static node * parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret, int *flags) { parser_state *ps; node *n; int started = 0; growable_int_array type_ignores; if (!growable_int_array_init(&type_ignores, 10)) { err_ret->error = E_NOMEM; Ta3Tokenizer_Free(tok); return NULL; } if ((ps = Ta3Parser_New(g, start)) == NULL) { err_ret->error = E_NOMEM; Ta3Tokenizer_Free(tok); return NULL; } #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (*flags & PyPARSE_BARRY_AS_BDFL) ps->p_flags |= CO_FUTURE_BARRY_AS_BDFL; #endif for (;;) { char *a, *b; int type; size_t len; char *str; int col_offset; type = Ta3Tokenizer_Get(tok, &a, &b); if (type == ERRORTOKEN) { err_ret->error = tok->done; break; } if (type == ENDMARKER && started) { type = NEWLINE; /* Add an extra newline */ started = 0; /* Add the right number of dedent tokens, except if a certain flag is given -- codeop.py uses this. */ if (tok->indent && !(*flags & PyPARSE_DONT_IMPLY_DEDENT)) { tok->pendin = -tok->indent; tok->indent = 0; } } else started = 1; len = b - a; /* XXX this may compute NULL - NULL */ str = (char *) PyObject_MALLOC(len + 1); if (str == NULL) { err_ret->error = E_NOMEM; break; } if (len > 0) strncpy(str, a, len); str[len] = '\0'; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD if (type == NOTEQUAL) { if (!(ps->p_flags & CO_FUTURE_BARRY_AS_BDFL) && strcmp(str, "!=")) { PyObject_FREE(str); err_ret->error = E_SYNTAX; break; } else if ((ps->p_flags & CO_FUTURE_BARRY_AS_BDFL) && strcmp(str, "<>")) { PyObject_FREE(str); err_ret->text = "with Barry as BDFL, use '<>' " "instead of '!='"; err_ret->error = E_SYNTAX; break; } } #endif if (a >= tok->line_start) col_offset = Py_SAFE_DOWNCAST(a - tok->line_start, intptr_t, int); else col_offset = -1; if (type == TYPE_IGNORE) { if (!growable_int_array_add(&type_ignores, tok->lineno)) { err_ret->error = E_NOMEM; break; } continue; } if ((err_ret->error = Ta3Parser_AddToken(ps, (int)type, str, tok->lineno, col_offset, &(err_ret->expected))) != E_OK) { if (err_ret->error != E_DONE) { PyObject_FREE(str); err_ret->token = type; } break; } } if (err_ret->error == E_DONE) { n = ps->p_tree; ps->p_tree = NULL; if (n->n_type == file_input) { /* Put type_ignore nodes in the ENDMARKER of file_input. */ int num; node *ch; size_t i; num = NCH(n); ch = CHILD(n, num - 1); REQ(ch, ENDMARKER); for (i = 0; i < type_ignores.num_items; i++) { Ta3Node_AddChild(ch, TYPE_IGNORE, NULL, type_ignores.items[i], 0); } } growable_int_array_deallocate(&type_ignores); #ifndef PGEN /* Check that the source for a single input statement really is a single statement by looking at what is left in the buffer after parsing. Trailing whitespace and comments are OK. */ if (start == single_input) { char *cur = tok->cur; char c = *tok->cur; for (;;) { while (c == ' ' || c == '\t' || c == '\n' || c == '\014') c = *++cur; if (!c) break; if (c != '#') { err_ret->error = E_BADSINGLE; Ta3Node_Free(n); n = NULL; break; } /* Suck up comment. */ while (c && c != '\n') c = *++cur; } } #endif } else n = NULL; #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD *flags = ps->p_flags; #endif Ta3Parser_Delete(ps); if (n == NULL) { if (tok->done == E_EOF) err_ret->error = E_EOF; err_ret->lineno = tok->lineno; if (tok->buf != NULL) { size_t len; assert(tok->cur - tok->buf < INT_MAX); err_ret->offset = (int)(tok->cur - tok->buf); len = tok->inp - tok->buf; err_ret->text = (char *) PyObject_MALLOC(len + 1); if (err_ret->text != NULL) { if (len > 0) strncpy(err_ret->text, tok->buf, len); err_ret->text[len] = '\0'; } } } else if (tok->encoding != NULL) { /* 'nodes->n_str' uses PyObject_*, while 'tok->encoding' was * allocated using PyMem_ */ node* r = Ta3Node_New(encoding_decl); if (r) r->n_str = PyObject_MALLOC(strlen(tok->encoding)+1); if (!r || !r->n_str) { err_ret->error = E_NOMEM; if (r) PyObject_FREE(r); n = NULL; goto done; } strcpy(r->n_str, tok->encoding); PyMem_FREE(tok->encoding); tok->encoding = NULL; r->n_nchildren = 1; r->n_child = n; n = r; } done: Ta3Tokenizer_Free(tok); return n; } static int initerr(perrdetail *err_ret, PyObject *filename) { err_ret->error = E_OK; err_ret->lineno = 0; err_ret->offset = 0; err_ret->text = NULL; err_ret->token = -1; err_ret->expected = -1; #ifndef PGEN if (filename) { Py_INCREF(filename); err_ret->filename = filename; } else { err_ret->filename = PyUnicode_FromString(""); if (err_ret->filename == NULL) { err_ret->error = E_ERROR; return -1; } } #endif return 0; } typed-ast-1.1.0/ast3/Parser/tokenizer.c0000644€Tøžæ€2›s®0000016072113050212017021202 0ustar ddfisher00000000000000 /* Tokenizer implementation */ #include "Python.h" #include "pgenheaders.h" #include #include #include "tokenizer.h" #include "errcode.h" #ifndef PGEN #include "unicodeobject.h" #include "bytesobject.h" #include "fileobject.h" #include "codecs.h" #include "abstract.h" #endif /* PGEN */ #ifndef Py_XSETREF #define Py_XSETREF(op, op2) \ do { \ PyObject *_py_tmp = (PyObject *)(op); \ (op) = (op2); \ Py_XDECREF(_py_tmp); \ } while (0) #endif /* Py_XSETREF */ #define is_potential_identifier_start(c) (\ (c >= 'a' && c <= 'z')\ || (c >= 'A' && c <= 'Z')\ || c == '_'\ || (c >= 128)) #define is_potential_identifier_char(c) (\ (c >= 'a' && c <= 'z')\ || (c >= 'A' && c <= 'Z')\ || (c >= '0' && c <= '9')\ || c == '_'\ || (c >= 128)) #if PY_MINOR_VERSION >= 4 PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); #else // Python 3.3 doesn't have PyAPI_FUNC, but it's not supported on Windows anyway. char *PyOS_Readline(FILE *, FILE *, char *); #endif /* Return malloc'ed string including trailing \n; empty malloc'ed string for EOF; NULL if interrupted */ /* Don't ever change this -- it would break the portability of Python code */ #define TABSIZE 8 /* Forward */ static struct tok_state *tok_new(void); static int tok_nextc(struct tok_state *tok); static void tok_backup(struct tok_state *tok, int c); /* Token names */ const char *_Ta3Parser_TokenNames[] = { "ENDMARKER", "NAME", "NUMBER", "STRING", "NEWLINE", "INDENT", "DEDENT", "LPAR", "RPAR", "LSQB", "RSQB", "COLON", "COMMA", "SEMI", "PLUS", "MINUS", "STAR", "SLASH", "VBAR", "AMPER", "LESS", "GREATER", "EQUAL", "DOT", "PERCENT", "LBRACE", "RBRACE", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", "GREATEREQUAL", "TILDE", "CIRCUMFLEX", "LEFTSHIFT", "RIGHTSHIFT", "DOUBLESTAR", "PLUSEQUAL", "MINEQUAL", "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", "RIGHTSHIFTEQUAL", "DOUBLESTAREQUAL", "DOUBLESLASH", "DOUBLESLASHEQUAL", "AT", "ATEQUAL", "RARROW", "ELLIPSIS", /* This table must match the #defines in token.h! */ "OP", "AWAIT", "ASYNC", "TYPE_IGNORE", "TYPE_COMMENT", "", "" }; /* Spaces in this constant are treated as "zero or more spaces or tabs" when tokenizing. */ static const char* type_comment_prefix = "# type: "; /* Create and initialize a new tok_state structure */ static struct tok_state * tok_new(void) { struct tok_state *tok = (struct tok_state *)PyMem_MALLOC( sizeof(struct tok_state)); if (tok == NULL) return NULL; tok->buf = tok->cur = tok->end = tok->inp = tok->start = NULL; tok->done = E_OK; tok->fp = NULL; tok->input = NULL; tok->tabsize = TABSIZE; tok->indent = 0; tok->indstack[0] = 0; tok->atbol = 1; tok->pendin = 0; tok->prompt = tok->nextprompt = NULL; tok->lineno = 0; tok->level = 0; tok->altwarning = 1; tok->alterror = 1; tok->alttabsize = 1; tok->altindstack[0] = 0; tok->decoding_state = STATE_INIT; tok->decoding_erred = 0; tok->read_coding_spec = 0; tok->enc = NULL; tok->encoding = NULL; tok->cont_line = 0; #ifndef PGEN tok->filename = NULL; tok->decoding_readline = NULL; tok->decoding_buffer = NULL; #endif tok->async_def = 0; tok->async_def_indent = 0; tok->async_def_nl = 0; return tok; } static char * new_string(const char *s, Py_ssize_t len, struct tok_state *tok) { char* result = (char *)PyMem_MALLOC(len + 1); if (!result) { tok->done = E_NOMEM; return NULL; } memcpy(result, s, len); result[len] = '\0'; return result; } #ifdef PGEN static char * decoding_fgets(char *s, int size, struct tok_state *tok) { return fgets(s, size, tok->fp); } static int decoding_feof(struct tok_state *tok) { return feof(tok->fp); } static char * decode_str(const char *str, int exec_input, struct tok_state *tok) { return new_string(str, strlen(str), tok); } #else /* PGEN */ static char * error_ret(struct tok_state *tok) /* XXX */ { tok->decoding_erred = 1; if (tok->fp != NULL && tok->buf != NULL) /* see Ta3Tokenizer_Free */ PyMem_FREE(tok->buf); tok->buf = tok->cur = tok->end = tok->inp = tok->start = NULL; tok->done = E_DECODE; return NULL; /* as if it were EOF */ } static const char * get_normal_name(const char *s) /* for utf-8 and latin-1 */ { char buf[13]; int i; for (i = 0; i < 12; i++) { int c = s[i]; if (c == '\0') break; else if (c == '_') buf[i] = '-'; else buf[i] = tolower(c); } buf[i] = '\0'; if (strcmp(buf, "utf-8") == 0 || strncmp(buf, "utf-8-", 6) == 0) return "utf-8"; else if (strcmp(buf, "latin-1") == 0 || strcmp(buf, "iso-8859-1") == 0 || strcmp(buf, "iso-latin-1") == 0 || strncmp(buf, "latin-1-", 8) == 0 || strncmp(buf, "iso-8859-1-", 11) == 0 || strncmp(buf, "iso-latin-1-", 12) == 0) return "iso-8859-1"; else return s; } /* Return the coding spec in S, or NULL if none is found. */ static int get_coding_spec(const char *s, char **spec, Py_ssize_t size, struct tok_state *tok) { Py_ssize_t i; *spec = NULL; /* Coding spec must be in a comment, and that comment must be * the only statement on the source code line. */ for (i = 0; i < size - 6; i++) { if (s[i] == '#') break; if (s[i] != ' ' && s[i] != '\t' && s[i] != '\014') return 1; } for (; i < size - 6; i++) { /* XXX inefficient search */ const char* t = s + i; if (strncmp(t, "coding", 6) == 0) { const char* begin = NULL; t += 6; if (t[0] != ':' && t[0] != '=') continue; do { t++; } while (t[0] == '\x20' || t[0] == '\t'); begin = t; while (Py_ISALNUM(t[0]) || t[0] == '-' || t[0] == '_' || t[0] == '.') t++; if (begin < t) { char* r = new_string(begin, t - begin, tok); const char* q; if (!r) return 0; q = get_normal_name(r); if (r != q) { PyMem_FREE(r); r = new_string(q, strlen(q), tok); if (!r) return 0; } *spec = r; break; } } } return 1; } /* Check whether the line contains a coding spec. If it does, invoke the set_readline function for the new encoding. This function receives the tok_state and the new encoding. Return 1 on success, 0 on failure. */ static int check_coding_spec(const char* line, Py_ssize_t size, struct tok_state *tok, int set_readline(struct tok_state *, const char *)) { char *cs; int r = 1; if (tok->cont_line) { /* It's a continuation line, so it can't be a coding spec. */ tok->read_coding_spec = 1; return 1; } if (!get_coding_spec(line, &cs, size, tok)) return 0; if (!cs) { Py_ssize_t i; for (i = 0; i < size; i++) { if (line[i] == '#' || line[i] == '\n' || line[i] == '\r') break; if (line[i] != ' ' && line[i] != '\t' && line[i] != '\014') { /* Stop checking coding spec after a line containing * anything except a comment. */ tok->read_coding_spec = 1; break; } } return 1; } tok->read_coding_spec = 1; if (tok->encoding == NULL) { assert(tok->decoding_state == STATE_RAW); if (strcmp(cs, "utf-8") == 0) { tok->encoding = cs; } else { r = set_readline(tok, cs); if (r) { tok->encoding = cs; tok->decoding_state = STATE_NORMAL; } else { PyErr_Format(PyExc_SyntaxError, "encoding problem: %s", cs); PyMem_FREE(cs); } } } else { /* then, compare cs with BOM */ r = (strcmp(tok->encoding, cs) == 0); if (!r) PyErr_Format(PyExc_SyntaxError, "encoding problem: %s with BOM", cs); PyMem_FREE(cs); } return r; } /* See whether the file starts with a BOM. If it does, invoke the set_readline function with the new encoding. Return 1 on success, 0 on failure. */ static int check_bom(int get_char(struct tok_state *), void unget_char(int, struct tok_state *), int set_readline(struct tok_state *, const char *), struct tok_state *tok) { int ch1, ch2, ch3; ch1 = get_char(tok); tok->decoding_state = STATE_RAW; if (ch1 == EOF) { return 1; } else if (ch1 == 0xEF) { ch2 = get_char(tok); if (ch2 != 0xBB) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } ch3 = get_char(tok); if (ch3 != 0xBF) { unget_char(ch3, tok); unget_char(ch2, tok); unget_char(ch1, tok); return 1; } #if 0 /* Disable support for UTF-16 BOMs until a decision is made whether this needs to be supported. */ } else if (ch1 == 0xFE) { ch2 = get_char(tok); if (ch2 != 0xFF) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } if (!set_readline(tok, "utf-16-be")) return 0; tok->decoding_state = STATE_NORMAL; } else if (ch1 == 0xFF) { ch2 = get_char(tok); if (ch2 != 0xFE) { unget_char(ch2, tok); unget_char(ch1, tok); return 1; } if (!set_readline(tok, "utf-16-le")) return 0; tok->decoding_state = STATE_NORMAL; #endif } else { unget_char(ch1, tok); return 1; } if (tok->encoding != NULL) PyMem_FREE(tok->encoding); tok->encoding = new_string("utf-8", 5, tok); if (!tok->encoding) return 0; /* No need to set_readline: input is already utf-8 */ return 1; } /* Read a line of text from TOK into S, using the stream in TOK. Return NULL on failure, else S. On entry, tok->decoding_buffer will be one of: 1) NULL: need to call tok->decoding_readline to get a new line 2) PyUnicodeObject *: decoding_feof has called tok->decoding_readline and stored the result in tok->decoding_buffer 3) PyByteArrayObject *: previous call to fp_readl did not have enough room (in the s buffer) to copy entire contents of the line read by tok->decoding_readline. tok->decoding_buffer has the overflow. In this case, fp_readl is called in a loop (with an expanded buffer) until the buffer ends with a '\n' (or until the end of the file is reached): see tok_nextc and its calls to decoding_fgets. */ static char * fp_readl(char *s, int size, struct tok_state *tok) { PyObject* bufobj; const char *buf; Py_ssize_t buflen; /* Ask for one less byte so we can terminate it */ assert(size > 0); size--; if (tok->decoding_buffer) { bufobj = tok->decoding_buffer; Py_INCREF(bufobj); } else { bufobj = PyObject_CallObject(tok->decoding_readline, NULL); if (bufobj == NULL) goto error; } if (PyUnicode_CheckExact(bufobj)) { buf = PyUnicode_AsUTF8AndSize(bufobj, &buflen); if (buf == NULL) { goto error; } } else { buf = PyByteArray_AsString(bufobj); if (buf == NULL) { goto error; } buflen = PyByteArray_GET_SIZE(bufobj); } Py_XDECREF(tok->decoding_buffer); if (buflen > size) { /* Too many chars, the rest goes into tok->decoding_buffer */ tok->decoding_buffer = PyByteArray_FromStringAndSize(buf+size, buflen-size); if (tok->decoding_buffer == NULL) goto error; buflen = size; } else tok->decoding_buffer = NULL; memcpy(s, buf, buflen); s[buflen] = '\0'; if (buflen == 0) /* EOF */ s = NULL; Py_DECREF(bufobj); return s; error: Py_XDECREF(bufobj); return error_ret(tok); } /* Set the readline function for TOK to a StreamReader's readline function. The StreamReader is named ENC. This function is called from check_bom and check_coding_spec. ENC is usually identical to the future value of tok->encoding, except for the (currently unsupported) case of UTF-16. Return 1 on success, 0 on failure. */ static int fp_setreadl(struct tok_state *tok, const char* enc) { PyObject *readline, *io, *stream; _Py_IDENTIFIER(open); _Py_IDENTIFIER(readline); int fd; long pos; fd = fileno(tok->fp); /* Due to buffering the file offset for fd can be different from the file * position of tok->fp. If tok->fp was opened in text mode on Windows, * its file position counts CRLF as one char and can't be directly mapped * to the file offset for fd. Instead we step back one byte and read to * the end of line.*/ pos = ftell(tok->fp); if (pos == -1 || lseek(fd, (off_t)(pos > 0 ? pos - 1 : pos), SEEK_SET) == (off_t)-1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, NULL); return 0; } io = PyImport_ImportModuleNoBlock("io"); if (io == NULL) return 0; stream = _PyObject_CallMethodId(io, &PyId_open, "isisOOO", fd, "r", -1, enc, Py_None, Py_None, Py_False); Py_DECREF(io); if (stream == NULL) return 0; readline = _PyObject_GetAttrId(stream, &PyId_readline); Py_DECREF(stream); if (readline == NULL) return 0; Py_XSETREF(tok->decoding_readline, readline); if (pos > 0) { PyObject *bufobj = PyObject_CallObject(readline, NULL); if (bufobj == NULL) return 0; Py_DECREF(bufobj); } return 1; } /* Fetch the next byte from TOK. */ static int fp_getc(struct tok_state *tok) { return getc(tok->fp); } /* Unfetch the last byte back into TOK. */ static void fp_ungetc(int c, struct tok_state *tok) { ungetc(c, tok->fp); } /* Check whether the characters at s start a valid UTF-8 sequence. Return the number of characters forming the sequence if yes, 0 if not. */ static int valid_utf8(const unsigned char* s) { int expected = 0; int length; if (*s < 0x80) /* single-byte code */ return 1; if (*s < 0xc0) /* following byte */ return 0; if (*s < 0xE0) expected = 1; else if (*s < 0xF0) expected = 2; else if (*s < 0xF8) expected = 3; else return 0; length = expected + 1; for (; expected; expected--) if (s[expected] < 0x80 || s[expected] >= 0xC0) return 0; return length; } /* Read a line of input from TOK. Determine encoding if necessary. */ static char * decoding_fgets(char *s, int size, struct tok_state *tok) { char *line = NULL; int badchar = 0; for (;;) { if (tok->decoding_state == STATE_NORMAL) { /* We already have a codec associated with this input. */ line = fp_readl(s, size, tok); break; } else if (tok->decoding_state == STATE_RAW) { /* We want a 'raw' read. */ line = Py_UniversalNewlineFgets(s, size, tok->fp, NULL); break; } else { /* We have not yet determined the encoding. If an encoding is found, use the file-pointer reader functions from now on. */ if (!check_bom(fp_getc, fp_ungetc, fp_setreadl, tok)) return error_ret(tok); assert(tok->decoding_state != STATE_INIT); } } if (line != NULL && tok->lineno < 2 && !tok->read_coding_spec) { if (!check_coding_spec(line, strlen(line), tok, fp_setreadl)) { return error_ret(tok); } } #ifndef PGEN /* The default encoding is UTF-8, so make sure we don't have any non-UTF-8 sequences in it. */ if (line && !tok->encoding) { unsigned char *c; int length; for (c = (unsigned char *)line; *c; c += length) if (!(length = valid_utf8(c))) { badchar = *c; break; } } if (badchar) { /* Need to add 1 to the line number, since this line has not been counted, yet. */ PyErr_Format(PyExc_SyntaxError, "Non-UTF-8 code starting with '\\x%.2x' " "in file %U on line %i, " "but no encoding declared; " "see http://python.org/dev/peps/pep-0263/ for details", badchar, tok->filename, tok->lineno + 1); return error_ret(tok); } #endif return line; } static int decoding_feof(struct tok_state *tok) { if (tok->decoding_state != STATE_NORMAL) { return feof(tok->fp); } else { PyObject* buf = tok->decoding_buffer; if (buf == NULL) { buf = PyObject_CallObject(tok->decoding_readline, NULL); if (buf == NULL) { error_ret(tok); return 1; } else { tok->decoding_buffer = buf; } } return PyObject_Length(buf) == 0; } } /* Fetch a byte from TOK, using the string buffer. */ static int buf_getc(struct tok_state *tok) { return Py_CHARMASK(*tok->str++); } /* Unfetch a byte from TOK, using the string buffer. */ static void buf_ungetc(int c, struct tok_state *tok) { tok->str--; assert(Py_CHARMASK(*tok->str) == c); /* tok->cur may point to read-only segment */ } /* Set the readline function for TOK to ENC. For the string-based tokenizer, this means to just record the encoding. */ static int buf_setreadl(struct tok_state *tok, const char* enc) { tok->enc = enc; return 1; } /* Return a UTF-8 encoding Python string object from the C byte string STR, which is encoded with ENC. */ static PyObject * translate_into_utf8(const char* str, const char* enc) { PyObject *utf8; PyObject* buf = PyUnicode_Decode(str, strlen(str), enc, NULL); if (buf == NULL) return NULL; utf8 = PyUnicode_AsUTF8String(buf); Py_DECREF(buf); return utf8; } static char * translate_newlines(const char *s, int exec_input, struct tok_state *tok) { int skip_next_lf = 0; size_t needed_length = strlen(s) + 2, final_length; char *buf, *current; char c = '\0'; buf = PyMem_MALLOC(needed_length); if (buf == NULL) { tok->done = E_NOMEM; return NULL; } for (current = buf; *s; s++, current++) { c = *s; if (skip_next_lf) { skip_next_lf = 0; if (c == '\n') { c = *++s; if (!c) break; } } if (c == '\r') { skip_next_lf = 1; c = '\n'; } *current = c; } /* If this is exec input, add a newline to the end of the string if there isn't one already. */ if (exec_input && c != '\n') { *current = '\n'; current++; } *current = '\0'; final_length = current - buf + 1; if (final_length < needed_length && final_length) /* should never fail */ buf = PyMem_REALLOC(buf, final_length); return buf; } /* Decode a byte string STR for use as the buffer of TOK. Look for encoding declarations inside STR, and record them inside TOK. */ static const char * decode_str(const char *input, int single, struct tok_state *tok) { PyObject* utf8 = NULL; const char *str; const char *s; const char *newl[2] = {NULL, NULL}; int lineno = 0; tok->input = str = translate_newlines(input, single, tok); if (str == NULL) return NULL; tok->enc = NULL; tok->str = str; if (!check_bom(buf_getc, buf_ungetc, buf_setreadl, tok)) return error_ret(tok); str = tok->str; /* string after BOM if any */ assert(str); if (tok->enc != NULL) { utf8 = translate_into_utf8(str, tok->enc); if (utf8 == NULL) return error_ret(tok); str = PyBytes_AsString(utf8); } for (s = str;; s++) { if (*s == '\0') break; else if (*s == '\n') { assert(lineno < 2); newl[lineno] = s; lineno++; if (lineno == 2) break; } } tok->enc = NULL; /* need to check line 1 and 2 separately since check_coding_spec assumes a single line as input */ if (newl[0]) { if (!check_coding_spec(str, newl[0] - str, tok, buf_setreadl)) return error_ret(tok); if (tok->enc == NULL && !tok->read_coding_spec && newl[1]) { if (!check_coding_spec(newl[0]+1, newl[1] - newl[0], tok, buf_setreadl)) return error_ret(tok); } } if (tok->enc != NULL) { assert(utf8 == NULL); utf8 = translate_into_utf8(str, tok->enc); if (utf8 == NULL) return error_ret(tok); str = PyBytes_AS_STRING(utf8); } assert(tok->decoding_buffer == NULL); tok->decoding_buffer = utf8; /* CAUTION */ return str; } #endif /* PGEN */ /* Set up tokenizer for string */ struct tok_state * Ta3Tokenizer_FromString(const char *str, int exec_input) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; str = decode_str(str, exec_input, tok); if (str == NULL) { Ta3Tokenizer_Free(tok); return NULL; } /* XXX: constify members. */ tok->buf = tok->cur = tok->end = tok->inp = (char*)str; return tok; } struct tok_state * Ta3Tokenizer_FromUTF8(const char *str, int exec_input) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; #ifndef PGEN tok->input = str = translate_newlines(str, exec_input, tok); #endif if (str == NULL) { Ta3Tokenizer_Free(tok); return NULL; } tok->decoding_state = STATE_RAW; tok->read_coding_spec = 1; tok->enc = NULL; tok->str = str; tok->encoding = (char *)PyMem_MALLOC(6); if (!tok->encoding) { Ta3Tokenizer_Free(tok); return NULL; } strcpy(tok->encoding, "utf-8"); /* XXX: constify members. */ tok->buf = tok->cur = tok->end = tok->inp = (char*)str; return tok; } /* Set up tokenizer for file */ struct tok_state * Ta3Tokenizer_FromFile(FILE *fp, const char* enc, const char *ps1, const char *ps2) { struct tok_state *tok = tok_new(); if (tok == NULL) return NULL; if ((tok->buf = (char *)PyMem_MALLOC(BUFSIZ)) == NULL) { Ta3Tokenizer_Free(tok); return NULL; } tok->cur = tok->inp = tok->buf; tok->end = tok->buf + BUFSIZ; tok->fp = fp; tok->prompt = ps1; tok->nextprompt = ps2; if (enc != NULL) { /* Must copy encoding declaration since it gets copied into the parse tree. */ tok->encoding = PyMem_MALLOC(strlen(enc)+1); if (!tok->encoding) { Ta3Tokenizer_Free(tok); return NULL; } strcpy(tok->encoding, enc); tok->decoding_state = STATE_NORMAL; } return tok; } /* Free a tok_state structure */ void Ta3Tokenizer_Free(struct tok_state *tok) { if (tok->encoding != NULL) PyMem_FREE(tok->encoding); #ifndef PGEN Py_XDECREF(tok->decoding_readline); Py_XDECREF(tok->decoding_buffer); Py_XDECREF(tok->filename); #endif if (tok->fp != NULL && tok->buf != NULL) PyMem_FREE(tok->buf); if (tok->input) PyMem_FREE((char *)tok->input); PyMem_FREE(tok); } /* Get next char, updating state; error code goes into tok->done */ static int tok_nextc(struct tok_state *tok) { for (;;) { if (tok->cur != tok->inp) { return Py_CHARMASK(*tok->cur++); /* Fast path */ } if (tok->done != E_OK) return EOF; if (tok->fp == NULL) { char *end = strchr(tok->inp, '\n'); if (end != NULL) end++; else { end = strchr(tok->inp, '\0'); if (end == tok->inp) { tok->done = E_EOF; return EOF; } } if (tok->start == NULL) tok->buf = tok->cur; tok->line_start = tok->cur; tok->lineno++; tok->inp = end; return Py_CHARMASK(*tok->cur++); } if (tok->prompt != NULL) { char *newtok = PyOS_Readline(stdin, stdout, tok->prompt); #ifndef PGEN if (newtok != NULL) { char *translated = translate_newlines(newtok, 0, tok); PyMem_FREE(newtok); if (translated == NULL) return EOF; newtok = translated; } if (tok->encoding && newtok && *newtok) { /* Recode to UTF-8 */ Py_ssize_t buflen; const char* buf; PyObject *u = translate_into_utf8(newtok, tok->encoding); PyMem_FREE(newtok); if (!u) { tok->done = E_DECODE; return EOF; } buflen = PyBytes_GET_SIZE(u); buf = PyBytes_AS_STRING(u); newtok = PyMem_MALLOC(buflen+1); strcpy(newtok, buf); Py_DECREF(u); } #endif if (tok->nextprompt != NULL) tok->prompt = tok->nextprompt; if (newtok == NULL) tok->done = E_INTR; else if (*newtok == '\0') { PyMem_FREE(newtok); tok->done = E_EOF; } else if (tok->start != NULL) { size_t start = tok->start - tok->buf; size_t oldlen = tok->cur - tok->buf; size_t newlen = oldlen + strlen(newtok); char *buf = tok->buf; buf = (char *)PyMem_REALLOC(buf, newlen+1); tok->lineno++; if (buf == NULL) { PyMem_FREE(tok->buf); tok->buf = NULL; PyMem_FREE(newtok); tok->done = E_NOMEM; return EOF; } tok->buf = buf; tok->cur = tok->buf + oldlen; tok->line_start = tok->cur; strcpy(tok->buf + oldlen, newtok); PyMem_FREE(newtok); tok->inp = tok->buf + newlen; tok->end = tok->inp + 1; tok->start = tok->buf + start; } else { tok->lineno++; if (tok->buf != NULL) PyMem_FREE(tok->buf); tok->buf = newtok; tok->cur = tok->buf; tok->line_start = tok->buf; tok->inp = strchr(tok->buf, '\0'); tok->end = tok->inp + 1; } } else { int done = 0; Py_ssize_t cur = 0; char *pt; if (tok->start == NULL) { if (tok->buf == NULL) { tok->buf = (char *) PyMem_MALLOC(BUFSIZ); if (tok->buf == NULL) { tok->done = E_NOMEM; return EOF; } tok->end = tok->buf + BUFSIZ; } if (decoding_fgets(tok->buf, (int)(tok->end - tok->buf), tok) == NULL) { if (!tok->decoding_erred) tok->done = E_EOF; done = 1; } else { tok->done = E_OK; tok->inp = strchr(tok->buf, '\0'); done = tok->inp == tok->buf || tok->inp[-1] == '\n'; } } else { cur = tok->cur - tok->buf; if (decoding_feof(tok)) { tok->done = E_EOF; done = 1; } else tok->done = E_OK; } tok->lineno++; /* Read until '\n' or EOF */ while (!done) { Py_ssize_t curstart = tok->start == NULL ? -1 : tok->start - tok->buf; Py_ssize_t curvalid = tok->inp - tok->buf; Py_ssize_t newsize = curvalid + BUFSIZ; char *newbuf = tok->buf; newbuf = (char *)PyMem_REALLOC(newbuf, newsize); if (newbuf == NULL) { tok->done = E_NOMEM; tok->cur = tok->inp; return EOF; } tok->buf = newbuf; tok->cur = tok->buf + cur; tok->line_start = tok->cur; tok->inp = tok->buf + curvalid; tok->end = tok->buf + newsize; tok->start = curstart < 0 ? NULL : tok->buf + curstart; if (decoding_fgets(tok->inp, (int)(tok->end - tok->inp), tok) == NULL) { /* Break out early on decoding errors, as tok->buf will be NULL */ if (tok->decoding_erred) return EOF; /* Last line does not end in \n, fake one */ strcpy(tok->inp, "\n"); } tok->inp = strchr(tok->inp, '\0'); done = tok->inp[-1] == '\n'; } if (tok->buf != NULL) { tok->cur = tok->buf + cur; tok->line_start = tok->cur; /* replace "\r\n" with "\n" */ /* For Mac leave the \r, giving a syntax error */ pt = tok->inp - 2; if (pt >= tok->buf && *pt == '\r') { *pt++ = '\n'; *pt = '\0'; tok->inp = pt; } } } if (tok->done != E_OK) { if (tok->prompt != NULL) PySys_WriteStderr("\n"); tok->cur = tok->inp; return EOF; } } /*NOTREACHED*/ } /* Back-up one character */ static void tok_backup(struct tok_state *tok, int c) { if (c != EOF) { if (--tok->cur < tok->buf) Py_FatalError("tok_backup: beginning of buffer"); if (*tok->cur != c) *tok->cur = c; } } /* Return the token corresponding to a single character */ int Ta3Token_OneChar(int c) { switch (c) { case '(': return LPAR; case ')': return RPAR; case '[': return LSQB; case ']': return RSQB; case ':': return COLON; case ',': return COMMA; case ';': return SEMI; case '+': return PLUS; case '-': return MINUS; case '*': return STAR; case '/': return SLASH; case '|': return VBAR; case '&': return AMPER; case '<': return LESS; case '>': return GREATER; case '=': return EQUAL; case '.': return DOT; case '%': return PERCENT; case '{': return LBRACE; case '}': return RBRACE; case '^': return CIRCUMFLEX; case '~': return TILDE; case '@': return AT; default: return OP; } } int Ta3Token_TwoChars(int c1, int c2) { switch (c1) { case '=': switch (c2) { case '=': return EQEQUAL; } break; case '!': switch (c2) { case '=': return NOTEQUAL; } break; case '<': switch (c2) { case '>': return NOTEQUAL; case '=': return LESSEQUAL; case '<': return LEFTSHIFT; } break; case '>': switch (c2) { case '=': return GREATEREQUAL; case '>': return RIGHTSHIFT; } break; case '+': switch (c2) { case '=': return PLUSEQUAL; } break; case '-': switch (c2) { case '=': return MINEQUAL; case '>': return RARROW; } break; case '*': switch (c2) { case '*': return DOUBLESTAR; case '=': return STAREQUAL; } break; case '/': switch (c2) { case '/': return DOUBLESLASH; case '=': return SLASHEQUAL; } break; case '|': switch (c2) { case '=': return VBAREQUAL; } break; case '%': switch (c2) { case '=': return PERCENTEQUAL; } break; case '&': switch (c2) { case '=': return AMPEREQUAL; } break; case '^': switch (c2) { case '=': return CIRCUMFLEXEQUAL; } break; case '@': switch (c2) { case '=': return ATEQUAL; } break; } return OP; } int Ta3Token_ThreeChars(int c1, int c2, int c3) { switch (c1) { case '<': switch (c2) { case '<': switch (c3) { case '=': return LEFTSHIFTEQUAL; } break; } break; case '>': switch (c2) { case '>': switch (c3) { case '=': return RIGHTSHIFTEQUAL; } break; } break; case '*': switch (c2) { case '*': switch (c3) { case '=': return DOUBLESTAREQUAL; } break; } break; case '/': switch (c2) { case '/': switch (c3) { case '=': return DOUBLESLASHEQUAL; } break; } break; case '.': switch (c2) { case '.': switch (c3) { case '.': return ELLIPSIS; } break; } break; } return OP; } static int indenterror(struct tok_state *tok) { if (tok->alterror) { tok->done = E_TABSPACE; tok->cur = tok->inp; return 1; } if (tok->altwarning) { #ifdef PGEN PySys_WriteStderr("inconsistent use of tabs and spaces " "in indentation\n"); #else PySys_FormatStderr("%U: inconsistent use of tabs and spaces " "in indentation\n", tok->filename); #endif tok->altwarning = 0; } return 0; } #ifdef PGEN #define verify_identifier(tok) 1 #else /* Verify that the identifier follows PEP 3131. All identifier strings are guaranteed to be "ready" unicode objects. */ static int verify_identifier(struct tok_state *tok) { PyObject *s; int result; if (tok->decoding_erred) return 0; s = PyUnicode_DecodeUTF8(tok->start, tok->cur - tok->start, NULL); if (s == NULL || PyUnicode_READY(s) == -1) { if (PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) { PyErr_Clear(); tok->done = E_IDENTIFIER; } else { tok->done = E_ERROR; } return 0; } result = PyUnicode_IsIdentifier(s); Py_DECREF(s); if (result == 0) tok->done = E_IDENTIFIER; return result; } #endif static int tok_decimal_tail(struct tok_state *tok) { int c; while (1) { do { c = tok_nextc(tok); } while (isdigit(c)); if (c != '_') { break; } c = tok_nextc(tok); if (!isdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return 0; } } return c; } /* Get next token, after space stripping etc. */ static int tok_get(struct tok_state *tok, char **p_start, char **p_end) { int c; int blankline, nonascii; *p_start = *p_end = NULL; nextline: tok->start = NULL; blankline = 0; /* Get indentation level */ if (tok->atbol) { int col = 0; int altcol = 0; tok->atbol = 0; for (;;) { c = tok_nextc(tok); if (c == ' ') { col++, altcol++; } else if (c == '\t') { col = (col/tok->tabsize + 1) * tok->tabsize; altcol = (altcol/tok->alttabsize + 1) * tok->alttabsize; } else if (c == '\014') {/* Control-L (formfeed) */ col = altcol = 0; /* For Emacs users */ } else { break; } } tok_backup(tok, c); if (c == '#' || c == '\n') { /* Lines with only whitespace and/or comments shouldn't affect the indentation and are not passed to the parser as NEWLINE tokens, except *totally* empty lines in interactive mode, which signal the end of a command group. */ if (col == 0 && c == '\n' && tok->prompt != NULL) { blankline = 0; /* Let it through */ } else { blankline = 1; /* Ignore completely */ } /* We can't jump back right here since we still may need to skip to the end of a comment */ } if (!blankline && tok->level == 0) { if (col == tok->indstack[tok->indent]) { /* No change */ if (altcol != tok->altindstack[tok->indent]) { if (indenterror(tok)) { return ERRORTOKEN; } } } else if (col > tok->indstack[tok->indent]) { /* Indent -- always one */ if (tok->indent+1 >= MAXINDENT) { tok->done = E_TOODEEP; tok->cur = tok->inp; return ERRORTOKEN; } if (altcol <= tok->altindstack[tok->indent]) { if (indenterror(tok)) { return ERRORTOKEN; } } tok->pendin++; tok->indstack[++tok->indent] = col; tok->altindstack[tok->indent] = altcol; } else /* col < tok->indstack[tok->indent] */ { /* Dedent -- any number, must be consistent */ while (tok->indent > 0 && col < tok->indstack[tok->indent]) { tok->pendin--; tok->indent--; } if (col != tok->indstack[tok->indent]) { tok->done = E_DEDENT; tok->cur = tok->inp; return ERRORTOKEN; } if (altcol != tok->altindstack[tok->indent]) { if (indenterror(tok)) { return ERRORTOKEN; } } } } } tok->start = tok->cur; /* Return pending indents/dedents */ if (tok->pendin != 0) { if (tok->pendin < 0) { tok->pendin++; return DEDENT; } else { tok->pendin--; return INDENT; } } if (tok->async_def && !blankline && tok->level == 0 /* There was a NEWLINE after ASYNC DEF, so we're past the signature. */ && tok->async_def_nl /* Current indentation level is less than where the async function was defined */ && tok->async_def_indent >= tok->indent) { tok->async_def = 0; tok->async_def_indent = 0; tok->async_def_nl = 0; } again: tok->start = NULL; /* Skip spaces */ do { c = tok_nextc(tok); } while (c == ' ' || c == '\t' || c == '\014'); /* Set start of current token */ tok->start = tok->cur - 1; /* Skip comment, unless it's a type comment */ if (c == '#') { const char *prefix, *p, *type_start; while (c != EOF && c != '\n') c = tok_nextc(tok); p = tok->start; prefix = type_comment_prefix; while (*prefix && p < tok->cur) { if (*prefix == ' ') { while (*p == ' ' || *p == '\t') p++; } else if (*prefix == *p) { p++; } else { break; } prefix++; } /* This is a type comment if we matched all of type_comment_prefix. */ if (!*prefix) { int is_type_ignore = 1; tok_backup(tok, c); /* don't eat the newline or EOF */ type_start = p; is_type_ignore = tok->cur >= p + 6 && memcmp(p, "ignore", 6) == 0; p += 6; while (is_type_ignore && p < tok->cur) { if (*p == '#') break; is_type_ignore = is_type_ignore && (*p == ' ' || *p == '\t'); p++; } if (is_type_ignore) { /* If this type ignore is the only thing on the line, consume the newline also. */ if (blankline) { tok_nextc(tok); tok->atbol = 1; } return TYPE_IGNORE; } else { *p_start = (char *) type_start; /* after type_comment_prefix */ *p_end = tok->cur; return TYPE_COMMENT; } } } /* Check for EOF and errors now */ if (c == EOF) { return tok->done == E_EOF ? ENDMARKER : ERRORTOKEN; } /* Identifier (most frequent token!) */ nonascii = 0; if (is_potential_identifier_start(c)) { /* Process b"", r"", u"", br"" and rb"" */ int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0; while (1) { if (!(saw_b || saw_u || saw_f) && (c == 'b' || c == 'B')) saw_b = 1; /* Since this is a backwards compatibility support literal we don't want to support it in arbitrary order like byte literals. */ else if (!(saw_b || saw_u || saw_r || saw_f) && (c == 'u'|| c == 'U')) { saw_u = 1; } /* ur"" and ru"" are not supported */ else if (!(saw_r || saw_u) && (c == 'r' || c == 'R')) { saw_r = 1; } else if (!(saw_f || saw_b || saw_u) && (c == 'f' || c == 'F')) { saw_f = 1; } else { break; } c = tok_nextc(tok); if (c == '"' || c == '\'') { goto letter_quote; } } while (is_potential_identifier_char(c)) { if (c >= 128) { nonascii = 1; } c = tok_nextc(tok); } tok_backup(tok, c); if (nonascii && !verify_identifier(tok)) { return ERRORTOKEN; } *p_start = tok->start; *p_end = tok->cur; /* async/await parsing block. */ if (tok->cur - tok->start == 5) { /* Current token length is 5. */ if (tok->async_def) { /* We're inside an 'async def' function. */ if (memcmp(tok->start, "async", 5) == 0) { return ASYNC; } if (memcmp(tok->start, "await", 5) == 0) { return AWAIT; } } else if (memcmp(tok->start, "async", 5) == 0) { /* The current token is 'async'. Look ahead one token.*/ struct tok_state ahead_tok; char *ahead_tok_start = NULL, *ahead_tok_end = NULL; int ahead_tok_kind; memcpy(&ahead_tok, tok, sizeof(ahead_tok)); ahead_tok_kind = tok_get(&ahead_tok, &ahead_tok_start, &ahead_tok_end); if (ahead_tok_kind == NAME && ahead_tok.cur - ahead_tok.start == 3 && memcmp(ahead_tok.start, "def", 3) == 0) { /* The next token is going to be 'def', so instead of returning 'async' NAME token, we return ASYNC. */ tok->async_def_indent = tok->indent; tok->async_def = 1; return ASYNC; } } } return NAME; } /* Newline */ if (c == '\n') { tok->atbol = 1; if (blankline || tok->level > 0) { goto nextline; } *p_start = tok->start; *p_end = tok->cur - 1; /* Leave '\n' out of the string */ tok->cont_line = 0; if (tok->async_def) { /* We're somewhere inside an 'async def' function, and we've encountered a NEWLINE after its signature. */ tok->async_def_nl = 1; } return NEWLINE; } /* Period or number starting with period? */ if (c == '.') { c = tok_nextc(tok); if (isdigit(c)) { goto fraction; } else if (c == '.') { c = tok_nextc(tok); if (c == '.') { *p_start = tok->start; *p_end = tok->cur; return ELLIPSIS; } else { tok_backup(tok, c); } tok_backup(tok, '.'); } else { tok_backup(tok, c); } *p_start = tok->start; *p_end = tok->cur; return DOT; } /* Number */ if (isdigit(c)) { if (c == '0') { /* Hex, octal or binary -- maybe. */ c = tok_nextc(tok); if (c == 'x' || c == 'X') { /* Hex */ c = tok_nextc(tok); do { if (c == '_') { c = tok_nextc(tok); } if (!isxdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while (isxdigit(c)); } while (c == '_'); } else if (c == 'o' || c == 'O') { /* Octal */ c = tok_nextc(tok); do { if (c == '_') { c = tok_nextc(tok); } if (c < '0' || c >= '8') { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while ('0' <= c && c < '8'); } while (c == '_'); } else if (c == 'b' || c == 'B') { /* Binary */ c = tok_nextc(tok); do { if (c == '_') { c = tok_nextc(tok); } if (c != '0' && c != '1') { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } do { c = tok_nextc(tok); } while (c == '0' || c == '1'); } while (c == '_'); } else { int nonzero = 0; /* maybe old-style octal; c is first char of it */ /* in any case, allow '0' as a literal */ while (1) { if (c == '_') { c = tok_nextc(tok); if (!isdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } } if (c != '0') { break; } c = tok_nextc(tok); } if (isdigit(c)) { nonzero = 1; c = tok_decimal_tail(tok); if (c == 0) { return ERRORTOKEN; } } if (c == '.') { c = tok_nextc(tok); goto fraction; } else if (c == 'e' || c == 'E') { goto exponent; } else if (c == 'j' || c == 'J') { goto imaginary; } else if (nonzero) { /* Old-style octal: now disallowed. */ tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } } } else { /* Decimal */ c = tok_decimal_tail(tok); if (c == 0) { return ERRORTOKEN; } { /* Accept floating point numbers. */ if (c == '.') { c = tok_nextc(tok); fraction: /* Fraction */ if (isdigit(c)) { c = tok_decimal_tail(tok); if (c == 0) { return ERRORTOKEN; } } } if (c == 'e' || c == 'E') { int e; exponent: e = c; /* Exponent part */ c = tok_nextc(tok); if (c == '+' || c == '-') { c = tok_nextc(tok); if (!isdigit(c)) { tok->done = E_TOKEN; tok_backup(tok, c); return ERRORTOKEN; } } else if (!isdigit(c)) { tok_backup(tok, c); tok_backup(tok, e); *p_start = tok->start; *p_end = tok->cur; return NUMBER; } c = tok_decimal_tail(tok); if (c == 0) { return ERRORTOKEN; } } if (c == 'j' || c == 'J') { /* Imaginary part */ imaginary: c = tok_nextc(tok); } } } tok_backup(tok, c); *p_start = tok->start; *p_end = tok->cur; return NUMBER; } letter_quote: /* String */ if (c == '\'' || c == '"') { int quote = c; int quote_size = 1; /* 1 or 3 */ int end_quote_size = 0; /* Find the quote size and start of string */ c = tok_nextc(tok); if (c == quote) { c = tok_nextc(tok); if (c == quote) { quote_size = 3; } else { end_quote_size = 1; /* empty string found */ } } if (c != quote) { tok_backup(tok, c); } /* Get rest of string */ while (end_quote_size != quote_size) { c = tok_nextc(tok); if (c == EOF) { if (quote_size == 3) { tok->done = E_EOFS; } else { tok->done = E_EOLS; } tok->cur = tok->inp; return ERRORTOKEN; } if (quote_size == 1 && c == '\n') { tok->done = E_EOLS; tok->cur = tok->inp; return ERRORTOKEN; } if (c == quote) { end_quote_size += 1; } else { end_quote_size = 0; if (c == '\\') { tok_nextc(tok); /* skip escaped char */ } } } *p_start = tok->start; *p_end = tok->cur; return STRING; } /* Line continuation */ if (c == '\\') { c = tok_nextc(tok); if (c != '\n') { tok->done = E_LINECONT; tok->cur = tok->inp; return ERRORTOKEN; } tok->cont_line = 1; goto again; /* Read next line */ } /* Check for two-character token */ { int c2 = tok_nextc(tok); int token = Ta3Token_TwoChars(c, c2); if (token != OP) { int c3 = tok_nextc(tok); int token3 = Ta3Token_ThreeChars(c, c2, c3); if (token3 != OP) { token = token3; } else { tok_backup(tok, c3); } *p_start = tok->start; *p_end = tok->cur; return token; } tok_backup(tok, c2); } /* Keep track of parentheses nesting level */ switch (c) { case '(': case '[': case '{': tok->level++; break; case ')': case ']': case '}': tok->level--; break; } /* Punctuation character */ *p_start = tok->start; *p_end = tok->cur; return Ta3Token_OneChar(c); } int Ta3Tokenizer_Get(struct tok_state *tok, char **p_start, char **p_end) { int result = tok_get(tok, p_start, p_end); if (tok->decoding_erred) { result = ERRORTOKEN; tok->done = E_DECODE; } return result; } /* Get the encoding of a Python file. Check for the coding cookie and check if the file starts with a BOM. Ta3Tokenizer_FindEncodingFilename() returns NULL when it can't find the encoding in the first or second line of the file (in which case the encoding should be assumed to be UTF-8). The char* returned is malloc'ed via PyMem_MALLOC() and thus must be freed by the caller. */ char * Ta3Tokenizer_FindEncodingFilename(int fd, PyObject *filename) { struct tok_state *tok; FILE *fp; char *p_start =NULL , *p_end =NULL , *encoding = NULL; #ifndef PGEN #if PY_MINOR_VERSION >= 4 fd = _Py_dup(fd); #endif #else fd = dup(fd); #endif if (fd < 0) { return NULL; } fp = fdopen(fd, "r"); if (fp == NULL) { return NULL; } tok = Ta3Tokenizer_FromFile(fp, NULL, NULL, NULL); if (tok == NULL) { fclose(fp); return NULL; } #ifndef PGEN if (filename != NULL) { Py_INCREF(filename); tok->filename = filename; } else { tok->filename = PyUnicode_FromString(""); if (tok->filename == NULL) { fclose(fp); Ta3Tokenizer_Free(tok); return encoding; } } #endif while (tok->lineno < 2 && tok->done == E_OK) { Ta3Tokenizer_Get(tok, &p_start, &p_end); } fclose(fp); if (tok->encoding) { encoding = (char *)PyMem_MALLOC(strlen(tok->encoding) + 1); if (encoding) strcpy(encoding, tok->encoding); } Ta3Tokenizer_Free(tok); return encoding; } char * Ta3Tokenizer_FindEncoding(int fd) { return Ta3Tokenizer_FindEncodingFilename(fd, NULL); } #ifdef Py_DEBUG void tok_dump(int type, char *start, char *end) { printf("%s", _Ta3Parser_TokenNames[type]); if (type == NAME || type == NUMBER || type == STRING || type == OP) printf("(%.*s)", (int)(end - start), start); } #endif typed-ast-1.1.0/ast3/Parser/tokenizer.h0000644€Tøžæ€2›s®0000000743213050212017021206 0ustar ddfisher00000000000000#ifndef Ta3_TOKENIZER_H #define Ta3_TOKENIZER_H #ifdef __cplusplus extern "C" { #endif #include "object.h" /* Tokenizer interface */ #include "token.h" /* For token types */ #define MAXINDENT 100 /* Max indentation level */ enum decoding_state { STATE_INIT, STATE_RAW, STATE_NORMAL /* have a codec associated with input */ }; /* Tokenizer state */ struct tok_state { /* Input state; buf <= cur <= inp <= end */ /* NB an entire line is held in the buffer */ char *buf; /* Input buffer, or NULL; malloc'ed if fp != NULL */ char *cur; /* Next character in buffer */ char *inp; /* End of data in buffer */ char *end; /* End of input buffer if buf != NULL */ char *start; /* Start of current token if not NULL */ int done; /* E_OK normally, E_EOF at EOF, otherwise error code */ /* NB If done != E_OK, cur must be == inp!!! */ FILE *fp; /* Rest of input; NULL if tokenizing a string */ int tabsize; /* Tab spacing */ int indent; /* Current indentation index */ int indstack[MAXINDENT]; /* Stack of indents */ int atbol; /* Nonzero if at begin of new line */ int pendin; /* Pending indents (if > 0) or dedents (if < 0) */ const char *prompt, *nextprompt; /* For interactive prompting */ int lineno; /* Current line number */ int level; /* () [] {} Parentheses nesting level */ /* Used to allow free continuations inside them */ /* Stuff for checking on different tab sizes */ #ifndef PGEN /* pgen doesn't have access to Python codecs, it cannot decode the input filename. The bytes filename might be kept, but it is only used by indenterror() and it is not really needed: pgen only compiles one file (Grammar/Grammar). */ PyObject *filename; #endif int altwarning; /* Issue warning if alternate tabs don't match */ int alterror; /* Issue error if alternate tabs don't match */ int alttabsize; /* Alternate tab spacing */ int altindstack[MAXINDENT]; /* Stack of alternate indents */ /* Stuff for PEP 0263 */ enum decoding_state decoding_state; int decoding_erred; /* whether erred in decoding */ int read_coding_spec; /* whether 'coding:...' has been read */ char *encoding; /* Source encoding. */ int cont_line; /* whether we are in a continuation line. */ const char* line_start; /* pointer to start of current line */ #ifndef PGEN PyObject *decoding_readline; /* open(...).readline */ PyObject *decoding_buffer; #endif const char* enc; /* Encoding for the current str. */ const char* str; const char* input; /* Tokenizer's newline translated copy of the string. */ /* async/await related fields; can be removed in 3.7 when async and await become normal keywords. */ int async_def; /* =1 if tokens are inside an 'async def' body. */ int async_def_indent; /* Indentation level of the outermost 'async def'. */ int async_def_nl; /* =1 if the outermost 'async def' had at least one NEWLINE token after it. */ }; extern struct tok_state *Ta3Tokenizer_FromString(const char *, int); extern struct tok_state *Ta3Tokenizer_FromUTF8(const char *, int); extern struct tok_state *Ta3Tokenizer_FromFile(FILE *, const char*, const char *, const char *); extern void Ta3Tokenizer_Free(struct tok_state *); extern int Ta3Tokenizer_Get(struct tok_state *, char **, char **); extern char * PyTokenizer_RestoreEncoding(struct tok_state* tok, int len, int *offset); #ifdef __cplusplus } #endif #endif /* !Ta3_TOKENIZER_H */ typed-ast-1.1.0/ast3/Python/0000755€Tøžæ€2›s®0000000000013133476735017067 5ustar ddfisher00000000000000typed-ast-1.1.0/ast3/Python/asdl.c0000644€Tøžæ€2›s®0000000262013050212017020131 0ustar ddfisher00000000000000#include "Python.h" #include "asdl.h" asdl_seq * _Ta3_asdl_seq_new(Py_ssize_t size, PyArena *arena) { asdl_seq *seq = NULL; size_t n; /* check size is sane */ if (size < 0 || (size && (((size_t)size - 1) > (SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } n += sizeof(asdl_seq); seq = (asdl_seq *)PyArena_Malloc(arena, n); if (!seq) { PyErr_NoMemory(); return NULL; } memset(seq, 0, n); seq->size = size; return seq; } asdl_int_seq * _Ta3_asdl_int_seq_new(Py_ssize_t size, PyArena *arena) { asdl_int_seq *seq = NULL; size_t n; /* check size is sane */ if (size < 0 || (size && (((size_t)size - 1) > (SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } n += sizeof(asdl_seq); seq = (asdl_int_seq *)PyArena_Malloc(arena, n); if (!seq) { PyErr_NoMemory(); return NULL; } memset(seq, 0, n); seq->size = size; return seq; } typed-ast-1.1.0/ast3/Python/ast.c0000644€Tøžæ€2›s®0000051166613133474673020040 0ustar ddfisher00000000000000/* * This file includes functions to transform a concrete syntax tree (CST) to * an abstract syntax tree (AST). The main function is Ta3AST_FromNode(). * */ #include "Python.h" #include "Python-ast.h" #include "node.h" #include "ast.h" #include "token.h" #include #if PY_MINOR_VERSION < 4 #define PyErr_ProgramTextObject PyErr_ProgramText #define PyMem_RawMalloc PyMem_Malloc #define PyMem_RawRealloc PyMem_Realloc #define PyMem_RawFree PyMem_Free #endif static int validate_stmts(asdl_seq *); static int validate_exprs(asdl_seq *, expr_context_ty, int); static int validate_nonempty_seq(asdl_seq *, const char *, const char *); static int validate_stmt(stmt_ty); static int validate_expr(expr_ty, expr_context_ty); mod_ty string_object_to_c_ast(const char *s, PyObject *filename, int start, PyCompilerFlags *flags, int feature_version, PyArena *arena); static int validate_comprehension(asdl_seq *gens) { int i; if (!asdl_seq_LEN(gens)) { PyErr_SetString(PyExc_ValueError, "comprehension with no generators"); return 0; } for (i = 0; i < asdl_seq_LEN(gens); i++) { comprehension_ty comp = asdl_seq_GET(gens, i); if (!validate_expr(comp->target, Store) || !validate_expr(comp->iter, Load) || !validate_exprs(comp->ifs, Load, 0)) return 0; } return 1; } static int validate_slice(slice_ty slice) { switch (slice->kind) { case Slice_kind: return (!slice->v.Slice.lower || validate_expr(slice->v.Slice.lower, Load)) && (!slice->v.Slice.upper || validate_expr(slice->v.Slice.upper, Load)) && (!slice->v.Slice.step || validate_expr(slice->v.Slice.step, Load)); case ExtSlice_kind: { int i; if (!validate_nonempty_seq(slice->v.ExtSlice.dims, "dims", "ExtSlice")) return 0; for (i = 0; i < asdl_seq_LEN(slice->v.ExtSlice.dims); i++) if (!validate_slice(asdl_seq_GET(slice->v.ExtSlice.dims, i))) return 0; return 1; } case Index_kind: return validate_expr(slice->v.Index.value, Load); default: PyErr_SetString(PyExc_SystemError, "unknown slice node"); return 0; } } static int validate_keywords(asdl_seq *keywords) { int i; for (i = 0; i < asdl_seq_LEN(keywords); i++) if (!validate_expr(((keyword_ty)asdl_seq_GET(keywords, i))->value, Load)) return 0; return 1; } static int validate_args(asdl_seq *args) { int i; for (i = 0; i < asdl_seq_LEN(args); i++) { arg_ty arg = asdl_seq_GET(args, i); if (arg->annotation && !validate_expr(arg->annotation, Load)) return 0; } return 1; } static const char * expr_context_name(expr_context_ty ctx) { switch (ctx) { case Load: return "Load"; case Store: return "Store"; case Del: return "Del"; case AugLoad: return "AugLoad"; case AugStore: return "AugStore"; case Param: return "Param"; default: assert(0); return "(unknown)"; } } static int validate_arguments(arguments_ty args) { if (!validate_args(args->args)) return 0; if (args->vararg && args->vararg->annotation && !validate_expr(args->vararg->annotation, Load)) { return 0; } if (!validate_args(args->kwonlyargs)) return 0; if (args->kwarg && args->kwarg->annotation && !validate_expr(args->kwarg->annotation, Load)) { return 0; } if (asdl_seq_LEN(args->defaults) > asdl_seq_LEN(args->args)) { PyErr_SetString(PyExc_ValueError, "more positional defaults than args on arguments"); return 0; } if (asdl_seq_LEN(args->kw_defaults) != asdl_seq_LEN(args->kwonlyargs)) { PyErr_SetString(PyExc_ValueError, "length of kwonlyargs is not the same as " "kw_defaults on arguments"); return 0; } return validate_exprs(args->defaults, Load, 0) && validate_exprs(args->kw_defaults, Load, 1); } static int validate_constant(PyObject *value) { if (value == Py_None || value == Py_Ellipsis) return 1; if (PyLong_CheckExact(value) || PyFloat_CheckExact(value) || PyComplex_CheckExact(value) || PyBool_Check(value) || PyUnicode_CheckExact(value) || PyBytes_CheckExact(value)) return 1; if (PyTuple_CheckExact(value) || PyFrozenSet_CheckExact(value)) { PyObject *it; it = PyObject_GetIter(value); if (it == NULL) return 0; while (1) { PyObject *item = PyIter_Next(it); if (item == NULL) { if (PyErr_Occurred()) { Py_DECREF(it); return 0; } break; } if (!validate_constant(item)) { Py_DECREF(it); Py_DECREF(item); return 0; } Py_DECREF(item); } Py_DECREF(it); return 1; } return 0; } static int validate_expr(expr_ty exp, expr_context_ty ctx) { int check_ctx = 1; expr_context_ty actual_ctx; /* First check expression context. */ switch (exp->kind) { case Attribute_kind: actual_ctx = exp->v.Attribute.ctx; break; case Subscript_kind: actual_ctx = exp->v.Subscript.ctx; break; case Starred_kind: actual_ctx = exp->v.Starred.ctx; break; case Name_kind: actual_ctx = exp->v.Name.ctx; break; case List_kind: actual_ctx = exp->v.List.ctx; break; case Tuple_kind: actual_ctx = exp->v.Tuple.ctx; break; default: if (ctx != Load) { PyErr_Format(PyExc_ValueError, "expression which can't be " "assigned to in %s context", expr_context_name(ctx)); return 0; } check_ctx = 0; /* set actual_ctx to prevent gcc warning */ actual_ctx = 0; } if (check_ctx && actual_ctx != ctx) { PyErr_Format(PyExc_ValueError, "expression must have %s context but has %s instead", expr_context_name(ctx), expr_context_name(actual_ctx)); return 0; } /* Now validate expression. */ switch (exp->kind) { case BoolOp_kind: if (asdl_seq_LEN(exp->v.BoolOp.values) < 2) { PyErr_SetString(PyExc_ValueError, "BoolOp with less than 2 values"); return 0; } return validate_exprs(exp->v.BoolOp.values, Load, 0); case BinOp_kind: return validate_expr(exp->v.BinOp.left, Load) && validate_expr(exp->v.BinOp.right, Load); case UnaryOp_kind: return validate_expr(exp->v.UnaryOp.operand, Load); case Lambda_kind: return validate_arguments(exp->v.Lambda.args) && validate_expr(exp->v.Lambda.body, Load); case IfExp_kind: return validate_expr(exp->v.IfExp.test, Load) && validate_expr(exp->v.IfExp.body, Load) && validate_expr(exp->v.IfExp.orelse, Load); case Dict_kind: if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) { PyErr_SetString(PyExc_ValueError, "Dict doesn't have the same number of keys as values"); return 0; } /* null_ok=1 for keys expressions to allow dict unpacking to work in dict literals, i.e. ``{**{a:b}}`` */ return validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) && validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0); case Set_kind: return validate_exprs(exp->v.Set.elts, Load, 0); #define COMP(NAME) \ case NAME ## _kind: \ return validate_comprehension(exp->v.NAME.generators) && \ validate_expr(exp->v.NAME.elt, Load); COMP(ListComp) COMP(SetComp) COMP(GeneratorExp) #undef COMP case DictComp_kind: return validate_comprehension(exp->v.DictComp.generators) && validate_expr(exp->v.DictComp.key, Load) && validate_expr(exp->v.DictComp.value, Load); case Yield_kind: return !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load); case YieldFrom_kind: return validate_expr(exp->v.YieldFrom.value, Load); case Await_kind: return validate_expr(exp->v.Await.value, Load); case Compare_kind: if (!asdl_seq_LEN(exp->v.Compare.comparators)) { PyErr_SetString(PyExc_ValueError, "Compare with no comparators"); return 0; } if (asdl_seq_LEN(exp->v.Compare.comparators) != asdl_seq_LEN(exp->v.Compare.ops)) { PyErr_SetString(PyExc_ValueError, "Compare has a different number " "of comparators and operands"); return 0; } return validate_exprs(exp->v.Compare.comparators, Load, 0) && validate_expr(exp->v.Compare.left, Load); case Call_kind: return validate_expr(exp->v.Call.func, Load) && validate_exprs(exp->v.Call.args, Load, 0) && validate_keywords(exp->v.Call.keywords); case Constant_kind: if (!validate_constant(exp->v.Constant.value)) { PyErr_Format(PyExc_TypeError, "got an invalid type in Constant: %s", Py_TYPE(exp->v.Constant.value)->tp_name); return 0; } return 1; case Num_kind: { PyObject *n = exp->v.Num.n; if (!PyLong_CheckExact(n) && !PyFloat_CheckExact(n) && !PyComplex_CheckExact(n)) { PyErr_SetString(PyExc_TypeError, "non-numeric type in Num"); return 0; } return 1; } case Str_kind: { PyObject *s = exp->v.Str.s; if (!PyUnicode_CheckExact(s)) { PyErr_SetString(PyExc_TypeError, "non-string type in Str"); return 0; } return 1; } case JoinedStr_kind: return validate_exprs(exp->v.JoinedStr.values, Load, 0); case FormattedValue_kind: if (validate_expr(exp->v.FormattedValue.value, Load) == 0) return 0; if (exp->v.FormattedValue.format_spec) return validate_expr(exp->v.FormattedValue.format_spec, Load); return 1; case Bytes_kind: { PyObject *b = exp->v.Bytes.s; if (!PyBytes_CheckExact(b)) { PyErr_SetString(PyExc_TypeError, "non-bytes type in Bytes"); return 0; } return 1; } case Attribute_kind: return validate_expr(exp->v.Attribute.value, Load); case Subscript_kind: return validate_slice(exp->v.Subscript.slice) && validate_expr(exp->v.Subscript.value, Load); case Starred_kind: return validate_expr(exp->v.Starred.value, ctx); case List_kind: return validate_exprs(exp->v.List.elts, ctx, 0); case Tuple_kind: return validate_exprs(exp->v.Tuple.elts, ctx, 0); /* These last cases don't have any checking. */ case Name_kind: case NameConstant_kind: case Ellipsis_kind: return 1; default: PyErr_SetString(PyExc_SystemError, "unexpected expression"); return 0; } } static int validate_nonempty_seq(asdl_seq *seq, const char *what, const char *owner) { if (asdl_seq_LEN(seq)) return 1; PyErr_Format(PyExc_ValueError, "empty %s on %s", what, owner); return 0; } static int validate_assignlist(asdl_seq *targets, expr_context_ty ctx) { return validate_nonempty_seq(targets, "targets", ctx == Del ? "Delete" : "Assign") && validate_exprs(targets, ctx, 0); } static int validate_body(asdl_seq *body, const char *owner) { return validate_nonempty_seq(body, "body", owner) && validate_stmts(body); } static int validate_stmt(stmt_ty stmt) { int i; switch (stmt->kind) { case FunctionDef_kind: return validate_body(stmt->v.FunctionDef.body, "FunctionDef") && validate_arguments(stmt->v.FunctionDef.args) && validate_exprs(stmt->v.FunctionDef.decorator_list, Load, 0) && (!stmt->v.FunctionDef.returns || validate_expr(stmt->v.FunctionDef.returns, Load)); case ClassDef_kind: return validate_body(stmt->v.ClassDef.body, "ClassDef") && validate_exprs(stmt->v.ClassDef.bases, Load, 0) && validate_keywords(stmt->v.ClassDef.keywords) && validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0); case Return_kind: return !stmt->v.Return.value || validate_expr(stmt->v.Return.value, Load); case Delete_kind: return validate_assignlist(stmt->v.Delete.targets, Del); case Assign_kind: return validate_assignlist(stmt->v.Assign.targets, Store) && validate_expr(stmt->v.Assign.value, Load); case AugAssign_kind: return validate_expr(stmt->v.AugAssign.target, Store) && validate_expr(stmt->v.AugAssign.value, Load); case AnnAssign_kind: if (stmt->v.AnnAssign.target->kind != Name_kind && stmt->v.AnnAssign.simple) { PyErr_SetString(PyExc_TypeError, "AnnAssign with simple non-Name target"); return 0; } return validate_expr(stmt->v.AnnAssign.target, Store) && (!stmt->v.AnnAssign.value || validate_expr(stmt->v.AnnAssign.value, Load)) && validate_expr(stmt->v.AnnAssign.annotation, Load); case For_kind: return validate_expr(stmt->v.For.target, Store) && validate_expr(stmt->v.For.iter, Load) && validate_body(stmt->v.For.body, "For") && validate_stmts(stmt->v.For.orelse); case AsyncFor_kind: return validate_expr(stmt->v.AsyncFor.target, Store) && validate_expr(stmt->v.AsyncFor.iter, Load) && validate_body(stmt->v.AsyncFor.body, "AsyncFor") && validate_stmts(stmt->v.AsyncFor.orelse); case While_kind: return validate_expr(stmt->v.While.test, Load) && validate_body(stmt->v.While.body, "While") && validate_stmts(stmt->v.While.orelse); case If_kind: return validate_expr(stmt->v.If.test, Load) && validate_body(stmt->v.If.body, "If") && validate_stmts(stmt->v.If.orelse); case With_kind: if (!validate_nonempty_seq(stmt->v.With.items, "items", "With")) return 0; for (i = 0; i < asdl_seq_LEN(stmt->v.With.items); i++) { withitem_ty item = asdl_seq_GET(stmt->v.With.items, i); if (!validate_expr(item->context_expr, Load) || (item->optional_vars && !validate_expr(item->optional_vars, Store))) return 0; } return validate_body(stmt->v.With.body, "With"); case AsyncWith_kind: if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith")) return 0; for (i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) { withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i); if (!validate_expr(item->context_expr, Load) || (item->optional_vars && !validate_expr(item->optional_vars, Store))) return 0; } return validate_body(stmt->v.AsyncWith.body, "AsyncWith"); case Raise_kind: if (stmt->v.Raise.exc) { return validate_expr(stmt->v.Raise.exc, Load) && (!stmt->v.Raise.cause || validate_expr(stmt->v.Raise.cause, Load)); } if (stmt->v.Raise.cause) { PyErr_SetString(PyExc_ValueError, "Raise with cause but no exception"); return 0; } return 1; case Try_kind: if (!validate_body(stmt->v.Try.body, "Try")) return 0; if (!asdl_seq_LEN(stmt->v.Try.handlers) && !asdl_seq_LEN(stmt->v.Try.finalbody)) { PyErr_SetString(PyExc_ValueError, "Try has neither except handlers nor finalbody"); return 0; } if (!asdl_seq_LEN(stmt->v.Try.handlers) && asdl_seq_LEN(stmt->v.Try.orelse)) { PyErr_SetString(PyExc_ValueError, "Try has orelse but no except handlers"); return 0; } for (i = 0; i < asdl_seq_LEN(stmt->v.Try.handlers); i++) { excepthandler_ty handler = asdl_seq_GET(stmt->v.Try.handlers, i); if ((handler->v.ExceptHandler.type && !validate_expr(handler->v.ExceptHandler.type, Load)) || !validate_body(handler->v.ExceptHandler.body, "ExceptHandler")) return 0; } return (!asdl_seq_LEN(stmt->v.Try.finalbody) || validate_stmts(stmt->v.Try.finalbody)) && (!asdl_seq_LEN(stmt->v.Try.orelse) || validate_stmts(stmt->v.Try.orelse)); case Assert_kind: return validate_expr(stmt->v.Assert.test, Load) && (!stmt->v.Assert.msg || validate_expr(stmt->v.Assert.msg, Load)); case Import_kind: return validate_nonempty_seq(stmt->v.Import.names, "names", "Import"); case ImportFrom_kind: if (stmt->v.ImportFrom.level < 0) { PyErr_SetString(PyExc_ValueError, "Negative ImportFrom level"); return 0; } return validate_nonempty_seq(stmt->v.ImportFrom.names, "names", "ImportFrom"); case Global_kind: return validate_nonempty_seq(stmt->v.Global.names, "names", "Global"); case Nonlocal_kind: return validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal"); case Expr_kind: return validate_expr(stmt->v.Expr.value, Load); case AsyncFunctionDef_kind: return validate_body(stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") && validate_arguments(stmt->v.AsyncFunctionDef.args) && validate_exprs(stmt->v.AsyncFunctionDef.decorator_list, Load, 0) && (!stmt->v.AsyncFunctionDef.returns || validate_expr(stmt->v.AsyncFunctionDef.returns, Load)); case Pass_kind: case Break_kind: case Continue_kind: return 1; default: PyErr_SetString(PyExc_SystemError, "unexpected statement"); return 0; } } static int validate_stmts(asdl_seq *seq) { int i; for (i = 0; i < asdl_seq_LEN(seq); i++) { stmt_ty stmt = asdl_seq_GET(seq, i); if (stmt) { if (!validate_stmt(stmt)) return 0; } else { PyErr_SetString(PyExc_ValueError, "None disallowed in statement list"); return 0; } } return 1; } static int validate_exprs(asdl_seq *exprs, expr_context_ty ctx, int null_ok) { int i; for (i = 0; i < asdl_seq_LEN(exprs); i++) { expr_ty expr = asdl_seq_GET(exprs, i); if (expr) { if (!validate_expr(expr, ctx)) return 0; } else if (!null_ok) { PyErr_SetString(PyExc_ValueError, "None disallowed in expression list"); return 0; } } return 1; } int Ta3AST_Validate(mod_ty mod) { int res = 0; switch (mod->kind) { case Module_kind: res = validate_stmts(mod->v.Module.body); break; case Interactive_kind: res = validate_stmts(mod->v.Interactive.body); break; case Expression_kind: res = validate_expr(mod->v.Expression.body, Load); break; case Suite_kind: PyErr_SetString(PyExc_ValueError, "Suite is not valid in the CPython compiler"); break; default: PyErr_SetString(PyExc_SystemError, "impossible module node"); res = 0; break; } return res; } /* This is done here, so defines like "test" don't interfere with AST use above. */ #include "grammar.h" #include "parsetok.h" #include "graminit.h" /* Data structure used internally */ struct compiling { PyArena *c_arena; /* Arena for allocating memory. */ PyObject *c_filename; /* filename */ PyObject *c_normalize; /* Normalization function from unicodedata. */ PyObject *c_normalize_args; /* Normalization argument tuple. */ int c_feature_version; /* Latest minior version of Python for allowed features */ }; static asdl_seq *seq_for_testlist(struct compiling *, const node *); static expr_ty ast_for_expr(struct compiling *, const node *); static stmt_ty ast_for_stmt(struct compiling *, const node *); static asdl_seq *ast_for_suite(struct compiling *, const node *); static asdl_seq *ast_for_exprlist(struct compiling *, const node *, expr_context_ty); static expr_ty ast_for_testlist(struct compiling *, const node *); static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *); static stmt_ty ast_for_with_stmt(struct compiling *, const node *, int); static stmt_ty ast_for_for_stmt(struct compiling *, const node *, int); /* Note different signature for ast_for_call */ static expr_ty ast_for_call(struct compiling *, const node *, expr_ty); static PyObject *parsenumber(struct compiling *, const char *); static expr_ty parsestrplus(struct compiling *, const node *n); #define COMP_GENEXP 0 #define COMP_LISTCOMP 1 #define COMP_SETCOMP 2 static int init_normalization(struct compiling *c) { PyObject *m = PyImport_ImportModuleNoBlock("unicodedata"); if (!m) return 0; c->c_normalize = PyObject_GetAttrString(m, "normalize"); Py_DECREF(m); if (!c->c_normalize) return 0; c->c_normalize_args = Py_BuildValue("(sN)", "NFKC", Py_None); if (!c->c_normalize_args) { Py_CLEAR(c->c_normalize); return 0; } PyTuple_SET_ITEM(c->c_normalize_args, 1, NULL); return 1; } static identifier new_identifier(const char *n, struct compiling *c) { PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL); if (!id) return NULL; /* PyUnicode_DecodeUTF8 should always return a ready string. */ assert(PyUnicode_IS_READY(id)); /* Check whether there are non-ASCII characters in the identifier; if so, normalize to NFKC. */ if (!PyUnicode_IS_ASCII(id)) { PyObject *id2; if (!c->c_normalize && !init_normalization(c)) { Py_DECREF(id); return NULL; } PyTuple_SET_ITEM(c->c_normalize_args, 1, id); id2 = PyObject_Call(c->c_normalize, c->c_normalize_args, NULL); Py_DECREF(id); if (!id2) return NULL; id = id2; } PyUnicode_InternInPlace(&id); if (PyArena_AddPyObject(c->c_arena, id) < 0) { Py_DECREF(id); return NULL; } return id; } #define NEW_IDENTIFIER(n) new_identifier(STR(n), c) static string new_type_comment(const char *s, struct compiling *c) { return PyUnicode_DecodeUTF8(s, strlen(s), NULL); } #define NEW_TYPE_COMMENT(n) new_type_comment(STR(n), c) static int ast_error(struct compiling *c, const node *n, const char *errmsg) { PyObject *value, *errstr, *loc, *tmp; loc = PyErr_ProgramTextObject(c->c_filename, LINENO(n)); if (!loc) { Py_INCREF(Py_None); loc = Py_None; } tmp = Py_BuildValue("(OiiN)", c->c_filename, LINENO(n), n->n_col_offset, loc); if (!tmp) return 0; errstr = PyUnicode_FromString(errmsg); if (!errstr) { Py_DECREF(tmp); return 0; } value = PyTuple_Pack(2, errstr, tmp); Py_DECREF(errstr); Py_DECREF(tmp); if (value) { PyErr_SetObject(PyExc_SyntaxError, value); Py_DECREF(value); } return 0; } /* num_stmts() returns number of contained statements. Use this routine to determine how big a sequence is needed for the statements in a parse tree. Its raison d'etre is this bit of grammar: stmt: simple_stmt | compound_stmt simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE A simple_stmt can contain multiple small_stmt elements joined by semicolons. If the arg is a simple_stmt, the number of small_stmt elements is returned. */ static int num_stmts(const node *n) { int i, l; node *ch; switch (TYPE(n)) { case single_input: if (TYPE(CHILD(n, 0)) == NEWLINE) return 0; else return num_stmts(CHILD(n, 0)); case file_input: l = 0; for (i = 0; i < NCH(n); i++) { ch = CHILD(n, i); if (TYPE(ch) == stmt) l += num_stmts(ch); } return l; case stmt: return num_stmts(CHILD(n, 0)); case compound_stmt: return 1; case simple_stmt: return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */ case suite: /* suite: simple_stmt | NEWLINE [TYPE_COMMENT NEWLINE] INDENT stmt+ DEDENT */ if (NCH(n) == 1) return num_stmts(CHILD(n, 0)); else { i = 2; l = 0; if (TYPE(CHILD(n, 1)) == TYPE_COMMENT) i += 2; for (; i < (NCH(n) - 1); i++) l += num_stmts(CHILD(n, i)); return l; } default: { char buf[128]; sprintf(buf, "Non-statement found: %d %d", TYPE(n), NCH(n)); Py_FatalError(buf); } } assert(0); return 0; } /* Transform the CST rooted at node * to the appropriate AST */ mod_ty Ta3AST_FromNodeObject(const node *n, PyCompilerFlags *flags, PyObject *filename, int feature_version, PyArena *arena) { int i, j, k, num; asdl_seq *stmts = NULL; asdl_seq *type_ignores = NULL; stmt_ty s; node *ch; struct compiling c; mod_ty res = NULL; asdl_seq *argtypes = NULL; expr_ty ret, arg; c.c_arena = arena; /* borrowed reference */ c.c_filename = filename; c.c_normalize = NULL; c.c_normalize_args = NULL; c.c_feature_version = feature_version; if (TYPE(n) == encoding_decl) n = CHILD(n, 0); k = 0; switch (TYPE(n)) { case file_input: stmts = _Ta3_asdl_seq_new(num_stmts(n), arena); if (!stmts) goto out; for (i = 0; i < NCH(n) - 1; i++) { ch = CHILD(n, i); if (TYPE(ch) == NEWLINE) continue; REQ(ch, stmt); num = num_stmts(ch); if (num == 1) { s = ast_for_stmt(&c, ch); if (!s) goto out; asdl_seq_SET(stmts, k++, s); } else { ch = CHILD(ch, 0); REQ(ch, simple_stmt); for (j = 0; j < num; j++) { s = ast_for_stmt(&c, CHILD(ch, j * 2)); if (!s) goto out; asdl_seq_SET(stmts, k++, s); } } } /* Type ignores are stored under the ENDMARKER in file_input. */ ch = CHILD(n, NCH(n) - 1); REQ(ch, ENDMARKER); num = NCH(ch); type_ignores = _Ta3_asdl_seq_new(num, arena); if (!type_ignores) goto out; for (i = 0; i < num; i++) { type_ignore_ty ti = TypeIgnore(LINENO(CHILD(ch, i)), arena); if (!ti) goto out; asdl_seq_SET(type_ignores, i, ti); } res = Module(stmts, type_ignores, arena); break; case eval_input: { expr_ty testlist_ast; /* XXX Why not comp_for here? */ testlist_ast = ast_for_testlist(&c, CHILD(n, 0)); if (!testlist_ast) goto out; res = Expression(testlist_ast, arena); break; } case single_input: if (TYPE(CHILD(n, 0)) == NEWLINE) { stmts = _Ta3_asdl_seq_new(1, arena); if (!stmts) goto out; asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset, arena)); if (!asdl_seq_GET(stmts, 0)) goto out; res = Interactive(stmts, arena); } else { n = CHILD(n, 0); num = num_stmts(n); stmts = _Ta3_asdl_seq_new(num, arena); if (!stmts) goto out; if (num == 1) { s = ast_for_stmt(&c, n); if (!s) goto out; asdl_seq_SET(stmts, 0, s); } else { /* Only a simple_stmt can contain multiple statements. */ REQ(n, simple_stmt); for (i = 0; i < NCH(n); i += 2) { if (TYPE(CHILD(n, i)) == NEWLINE) break; s = ast_for_stmt(&c, CHILD(n, i)); if (!s) goto out; asdl_seq_SET(stmts, i / 2, s); } } res = Interactive(stmts, arena); } break; case func_type_input: n = CHILD(n, 0); REQ(n, func_type); if (TYPE(CHILD(n, 1)) == typelist) { ch = CHILD(n, 1); /* this is overly permissive -- we don't pay any attention to * stars on the args -- just parse them into an ordered list */ num = 0; for (i = 0; i < NCH(ch); i++) { if (TYPE(CHILD(ch, i)) == test) num++; } argtypes = _Ta3_asdl_seq_new(num, arena); j = 0; for (i = 0; i < NCH(ch); i++) { if (TYPE(CHILD(ch, i)) == test) { arg = ast_for_expr(&c, CHILD(ch, i)); if (!arg) goto out; asdl_seq_SET(argtypes, j++, arg); } } } else argtypes = _Ta3_asdl_seq_new(0, arena); ret = ast_for_expr(&c, CHILD(n, NCH(n) - 1)); if (!ret) goto out; res = FunctionType(argtypes, ret, arena); break; default: PyErr_Format(PyExc_SystemError, "invalid node %d for Ta3AST_FromNode", TYPE(n)); goto out; } out: if (c.c_normalize) { Py_DECREF(c.c_normalize); PyTuple_SET_ITEM(c.c_normalize_args, 1, NULL); Py_DECREF(c.c_normalize_args); } return res; } mod_ty Ta3AST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename_str, int feature_version, PyArena *arena) { mod_ty mod; PyObject *filename; filename = PyUnicode_DecodeFSDefault(filename_str); if (filename == NULL) return NULL; mod = Ta3AST_FromNodeObject(n, flags, filename, feature_version, arena); Py_DECREF(filename); return mod; } /* Return the AST repr. of the operator represented as syntax (|, ^, etc.) */ static operator_ty get_operator(struct compiling *c, const node *n) { switch (TYPE(n)) { case VBAR: return BitOr; case CIRCUMFLEX: return BitXor; case AMPER: return BitAnd; case LEFTSHIFT: return LShift; case RIGHTSHIFT: return RShift; case PLUS: return Add; case MINUS: return Sub; case STAR: return Mult; case AT: if (c->c_feature_version < 5) { ast_error(c, n, "The '@' operator is only supported in Python 3.5 and greater"); return (operator_ty)0; } return MatMult; case SLASH: return Div; case DOUBLESLASH: return FloorDiv; case PERCENT: return Mod; default: return (operator_ty)0; } } static const char * const FORBIDDEN[] = { "None", "True", "False", NULL, }; static int forbidden_name(struct compiling *c, identifier name, const node *n, int full_checks) { assert(PyUnicode_Check(name)); if (PyUnicode_CompareWithASCIIString(name, "__debug__") == 0) { ast_error(c, n, "assignment to keyword"); return 1; } if (full_checks) { const char * const *p; for (p = FORBIDDEN; *p; p++) { if (PyUnicode_CompareWithASCIIString(name, *p) == 0) { ast_error(c, n, "assignment to keyword"); return 1; } } } return 0; } /* Set the context ctx for expr_ty e, recursively traversing e. Only sets context for expr kinds that "can appear in assignment context" (according to ../Parser/Python.asdl). For other expr kinds, it sets an appropriate syntax error and returns false. */ static int set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n) { asdl_seq *s = NULL; /* If a particular expression type can't be used for assign / delete, set expr_name to its name and an error message will be generated. */ const char* expr_name = NULL; /* The ast defines augmented store and load contexts, but the implementation here doesn't actually use them. The code may be a little more complex than necessary as a result. It also means that expressions in an augmented assignment have a Store context. Consider restructuring so that augmented assignment uses set_context(), too. */ assert(ctx != AugStore && ctx != AugLoad); switch (e->kind) { case Attribute_kind: e->v.Attribute.ctx = ctx; if (ctx == Store && forbidden_name(c, e->v.Attribute.attr, n, 1)) return 0; break; case Subscript_kind: e->v.Subscript.ctx = ctx; break; case Starred_kind: e->v.Starred.ctx = ctx; if (!set_context(c, e->v.Starred.value, ctx, n)) return 0; break; case Name_kind: if (ctx == Store) { if (forbidden_name(c, e->v.Name.id, n, 0)) return 0; /* forbidden_name() calls ast_error() */ } e->v.Name.ctx = ctx; break; case List_kind: e->v.List.ctx = ctx; s = e->v.List.elts; break; case Tuple_kind: e->v.Tuple.ctx = ctx; s = e->v.Tuple.elts; break; case Lambda_kind: expr_name = "lambda"; break; case Call_kind: expr_name = "function call"; break; case BoolOp_kind: case BinOp_kind: case UnaryOp_kind: expr_name = "operator"; break; case GeneratorExp_kind: expr_name = "generator expression"; break; case Yield_kind: case YieldFrom_kind: expr_name = "yield expression"; break; case Await_kind: expr_name = "await expression"; break; case ListComp_kind: expr_name = "list comprehension"; break; case SetComp_kind: expr_name = "set comprehension"; break; case DictComp_kind: expr_name = "dict comprehension"; break; case Dict_kind: case Set_kind: case Num_kind: case Str_kind: case Bytes_kind: case JoinedStr_kind: case FormattedValue_kind: expr_name = "literal"; break; case NameConstant_kind: expr_name = "keyword"; break; case Ellipsis_kind: expr_name = "Ellipsis"; break; case Compare_kind: expr_name = "comparison"; break; case IfExp_kind: expr_name = "conditional expression"; break; default: PyErr_Format(PyExc_SystemError, "unexpected expression in assignment %d (line %d)", e->kind, e->lineno); return 0; } /* Check for error string set by switch */ if (expr_name) { char buf[300]; PyOS_snprintf(buf, sizeof(buf), "can't %s %s", ctx == Store ? "assign to" : "delete", expr_name); return ast_error(c, n, buf); } /* If the LHS is a list or tuple, we need to set the assignment context for all the contained elements. */ if (s) { int i; for (i = 0; i < asdl_seq_LEN(s); i++) { if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n)) return 0; } } return 1; } static operator_ty ast_for_augassign(struct compiling *c, const node *n) { REQ(n, augassign); n = CHILD(n, 0); switch (STR(n)[0]) { case '+': return Add; case '-': return Sub; case '/': if (STR(n)[1] == '/') return FloorDiv; else return Div; case '%': return Mod; case '<': return LShift; case '>': return RShift; case '&': return BitAnd; case '^': return BitXor; case '|': return BitOr; case '*': if (STR(n)[1] == '*') return Pow; else return Mult; case '@': if (c->c_feature_version < 5) { ast_error(c, n, "The '@' operator is only supported in Python 3.5 and greater"); return (operator_ty)0; } return MatMult; default: PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n)); return (operator_ty)0; } } static cmpop_ty ast_for_comp_op(struct compiling *c, const node *n) { /* comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'in'|'not' 'in'|'is' |'is' 'not' */ REQ(n, comp_op); if (NCH(n) == 1) { n = CHILD(n, 0); switch (TYPE(n)) { case LESS: return Lt; case GREATER: return Gt; case EQEQUAL: /* == */ return Eq; case LESSEQUAL: return LtE; case GREATEREQUAL: return GtE; case NOTEQUAL: return NotEq; case NAME: if (strcmp(STR(n), "in") == 0) return In; if (strcmp(STR(n), "is") == 0) return Is; default: PyErr_Format(PyExc_SystemError, "invalid comp_op: %s", STR(n)); return (cmpop_ty)0; } } else if (NCH(n) == 2) { /* handle "not in" and "is not" */ switch (TYPE(CHILD(n, 0))) { case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0) return NotIn; if (strcmp(STR(CHILD(n, 0)), "is") == 0) return IsNot; default: PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s", STR(CHILD(n, 0)), STR(CHILD(n, 1))); return (cmpop_ty)0; } } PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children", NCH(n)); return (cmpop_ty)0; } static asdl_seq * seq_for_testlist(struct compiling *c, const node *n) { /* testlist: test (',' test)* [','] testlist_star_expr: test|star_expr (',' test|star_expr)* [','] */ asdl_seq *seq; expr_ty expression; int i; assert(TYPE(n) == testlist || TYPE(n) == testlist_star_expr || TYPE(n) == testlist_comp); seq = _Ta3_asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { const node *ch = CHILD(n, i); assert(TYPE(ch) == test || TYPE(ch) == test_nocond || TYPE(ch) == star_expr); expression = ast_for_expr(c, ch); if (!expression) return NULL; assert(i / 2 < seq->size); asdl_seq_SET(seq, i / 2, expression); } return seq; } static arg_ty ast_for_arg(struct compiling *c, const node *n) { identifier name; expr_ty annotation = NULL; node *ch; arg_ty ret; assert(TYPE(n) == tfpdef || TYPE(n) == vfpdef); ch = CHILD(n, 0); name = NEW_IDENTIFIER(ch); if (!name) return NULL; if (forbidden_name(c, name, ch, 0)) return NULL; if (NCH(n) == 3 && TYPE(CHILD(n, 1)) == COLON) { annotation = ast_for_expr(c, CHILD(n, 2)); if (!annotation) return NULL; } ret = arg(name, annotation, NULL, LINENO(n), n->n_col_offset, c->c_arena); if (!ret) return NULL; return ret; } /* returns -1 if failed to handle keyword only arguments returns new position to keep processing if successful (',' tfpdef ['=' test])* ^^^ start pointing here */ static int handle_keywordonly_args(struct compiling *c, const node *n, int start, asdl_seq *kwonlyargs, asdl_seq *kwdefaults) { PyObject *argname; node *ch; expr_ty expression, annotation; arg_ty arg; int i = start; int j = 0; /* index for kwdefaults and kwonlyargs */ if (kwonlyargs == NULL) { ast_error(c, CHILD(n, start), "named arguments must follow bare *"); return -1; } assert(kwdefaults != NULL); while (i < NCH(n)) { ch = CHILD(n, i); switch (TYPE(ch)) { case vfpdef: case tfpdef: if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) { expression = ast_for_expr(c, CHILD(n, i + 2)); if (!expression) goto error; asdl_seq_SET(kwdefaults, j, expression); i += 2; /* '=' and test */ } else { /* setting NULL if no default value exists */ asdl_seq_SET(kwdefaults, j, NULL); } if (NCH(ch) == 3) { /* ch is NAME ':' test */ annotation = ast_for_expr(c, CHILD(ch, 2)); if (!annotation) goto error; } else { annotation = NULL; } ch = CHILD(ch, 0); argname = NEW_IDENTIFIER(ch); if (!argname) goto error; if (forbidden_name(c, argname, ch, 0)) goto error; arg = arg(argname, annotation, NULL, LINENO(ch), ch->n_col_offset, c->c_arena); if (!arg) goto error; asdl_seq_SET(kwonlyargs, j++, arg); i += 1; /* the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ break; case TYPE_COMMENT: /* arg will be equal to the last argument processed */ arg->type_comment = NEW_TYPE_COMMENT(ch); i += 1; break; case DOUBLESTAR: return i; default: ast_error(c, ch, "unexpected node"); goto error; } } return i; error: return -1; } /* Create AST for argument list. */ static arguments_ty ast_for_arguments(struct compiling *c, const node *n) { /* This function handles both typedargslist (function definition) and varargslist (lambda definition). parameters: '(' [typedargslist] ')' typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [ '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] | '**' tfpdef [',']]] | '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] | '**' tfpdef [',']) tfpdef: NAME [':' test] varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] | '**' vfpdef [',']]] | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] | '**' vfpdef [','] ) vfpdef: NAME */ int i, j, k, nposargs = 0, nkwonlyargs = 0; int nposdefaults = 0, found_default = 0; asdl_seq *posargs, *posdefaults, *kwonlyargs, *kwdefaults; arg_ty vararg = NULL, kwarg = NULL; arg_ty arg; node *ch; if (TYPE(n) == parameters) { if (NCH(n) == 2) /* () as argument list */ return arguments(NULL, NULL, NULL, NULL, NULL, NULL, c->c_arena); n = CHILD(n, 1); } assert(TYPE(n) == typedargslist || TYPE(n) == varargslist); /* First count the number of positional args & defaults. The variable i is the loop index for this for loop and the next. The next loop picks up where the first leaves off. */ for (i = 0; i < NCH(n); i++) { ch = CHILD(n, i); if (TYPE(ch) == STAR) { /* skip star */ i++; if (i < NCH(n) && /* skip argument following star */ (TYPE(CHILD(n, i)) == tfpdef || TYPE(CHILD(n, i)) == vfpdef)) { i++; } break; } if (TYPE(ch) == DOUBLESTAR) break; if (TYPE(ch) == vfpdef || TYPE(ch) == tfpdef) nposargs++; if (TYPE(ch) == EQUAL) nposdefaults++; } /* count the number of keyword only args & defaults for keyword only args */ for ( ; i < NCH(n); ++i) { ch = CHILD(n, i); if (TYPE(ch) == DOUBLESTAR) break; if (TYPE(ch) == tfpdef || TYPE(ch) == vfpdef) nkwonlyargs++; } posargs = (nposargs ? _Ta3_asdl_seq_new(nposargs, c->c_arena) : NULL); if (!posargs && nposargs) return NULL; kwonlyargs = (nkwonlyargs ? _Ta3_asdl_seq_new(nkwonlyargs, c->c_arena) : NULL); if (!kwonlyargs && nkwonlyargs) return NULL; posdefaults = (nposdefaults ? _Ta3_asdl_seq_new(nposdefaults, c->c_arena) : NULL); if (!posdefaults && nposdefaults) return NULL; /* The length of kwonlyargs and kwdefaults are same since we set NULL as default for keyword only argument w/o default - we have sequence data structure, but no dictionary */ kwdefaults = (nkwonlyargs ? _Ta3_asdl_seq_new(nkwonlyargs, c->c_arena) : NULL); if (!kwdefaults && nkwonlyargs) return NULL; if (nposargs + nkwonlyargs > 255) { ast_error(c, n, "more than 255 arguments"); return NULL; } /* tfpdef: NAME [':' test] vfpdef: NAME */ i = 0; j = 0; /* index for defaults */ k = 0; /* index for args */ while (i < NCH(n)) { ch = CHILD(n, i); switch (TYPE(ch)) { case tfpdef: case vfpdef: /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is anything other than EQUAL or a comma? */ /* XXX Should NCH(n) check be made a separate check? */ if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) { expr_ty expression = ast_for_expr(c, CHILD(n, i + 2)); if (!expression) return NULL; assert(posdefaults != NULL); asdl_seq_SET(posdefaults, j++, expression); i += 2; found_default = 1; } else if (found_default) { ast_error(c, n, "non-default argument follows default argument"); return NULL; } arg = ast_for_arg(c, ch); if (!arg) return NULL; asdl_seq_SET(posargs, k++, arg); i += 1; /* the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ break; case STAR: if (i+1 >= NCH(n) || (i+2 == NCH(n) && (TYPE(CHILD(n, i+1)) == COMMA || TYPE(CHILD(n, i+1)) == TYPE_COMMENT))) { ast_error(c, CHILD(n, i), "named arguments must follow bare *"); return NULL; } ch = CHILD(n, i+1); /* tfpdef or COMMA */ if (TYPE(ch) == COMMA) { int res = 0; i += 2; /* now follows keyword only arguments */ if (i < NCH(n) && TYPE(CHILD(n, i)) == TYPE_COMMENT) { ast_error(c, CHILD(n, i), "bare * has associated type comment"); return NULL; } res = handle_keywordonly_args(c, n, i, kwonlyargs, kwdefaults); if (res == -1) return NULL; i = res; /* res has new position to process */ } else { vararg = ast_for_arg(c, ch); if (!vararg) return NULL; i += 2; /* the star and the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ if (i < NCH(n) && TYPE(CHILD(n, i)) == TYPE_COMMENT) { vararg->type_comment = NEW_TYPE_COMMENT(CHILD(n, i)); i += 1; } if (i < NCH(n) && (TYPE(CHILD(n, i)) == tfpdef || TYPE(CHILD(n, i)) == vfpdef)) { int res = 0; res = handle_keywordonly_args(c, n, i, kwonlyargs, kwdefaults); if (res == -1) return NULL; i = res; /* res has new position to process */ } } break; case DOUBLESTAR: ch = CHILD(n, i+1); /* tfpdef */ assert(TYPE(ch) == tfpdef || TYPE(ch) == vfpdef); kwarg = ast_for_arg(c, ch); if (!kwarg) return NULL; i += 2; /* the double star and the name */ if (i < NCH(n) && TYPE(CHILD(n, i)) == COMMA) i += 1; /* the comma, if present */ break; case TYPE_COMMENT: assert(i); if (kwarg) arg = kwarg; /* arg will be equal to the last argument processed */ arg->type_comment = NEW_TYPE_COMMENT(ch); i += 1; break; default: PyErr_Format(PyExc_SystemError, "unexpected node in varargslist: %d @ %d", TYPE(ch), i); return NULL; } } return arguments(posargs, vararg, kwonlyargs, kwdefaults, kwarg, posdefaults, c->c_arena); } static expr_ty ast_for_dotted_name(struct compiling *c, const node *n) { expr_ty e; identifier id; int lineno, col_offset; int i; REQ(n, dotted_name); lineno = LINENO(n); col_offset = n->n_col_offset; id = NEW_IDENTIFIER(CHILD(n, 0)); if (!id) return NULL; e = Name(id, Load, lineno, col_offset, c->c_arena); if (!e) return NULL; for (i = 2; i < NCH(n); i+=2) { id = NEW_IDENTIFIER(CHILD(n, i)); if (!id) return NULL; e = Attribute(e, id, Load, lineno, col_offset, c->c_arena); if (!e) return NULL; } return e; } static expr_ty ast_for_decorator(struct compiling *c, const node *n) { /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */ expr_ty d = NULL; expr_ty name_expr; REQ(n, decorator); REQ(CHILD(n, 0), AT); REQ(RCHILD(n, -1), NEWLINE); name_expr = ast_for_dotted_name(c, CHILD(n, 1)); if (!name_expr) return NULL; if (NCH(n) == 3) { /* No arguments */ d = name_expr; name_expr = NULL; } else if (NCH(n) == 5) { /* Call with no arguments */ d = Call(name_expr, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); if (!d) return NULL; name_expr = NULL; } else { d = ast_for_call(c, CHILD(n, 3), name_expr); if (!d) return NULL; name_expr = NULL; } return d; } static asdl_seq* ast_for_decorators(struct compiling *c, const node *n) { asdl_seq* decorator_seq; expr_ty d; int i; REQ(n, decorators); decorator_seq = _Ta3_asdl_seq_new(NCH(n), c->c_arena); if (!decorator_seq) return NULL; for (i = 0; i < NCH(n); i++) { d = ast_for_decorator(c, CHILD(n, i)); if (!d) return NULL; asdl_seq_SET(decorator_seq, i, d); } return decorator_seq; } static stmt_ty ast_for_funcdef_impl(struct compiling *c, const node *n, asdl_seq *decorator_seq, int is_async) { /* funcdef: 'def' NAME parameters ['->' test] ':' [TYPE_COMMENT] suite */ identifier name; arguments_ty args; asdl_seq *body; expr_ty returns = NULL; int name_i = 1; node *tc; string type_comment = NULL; if (is_async && c->c_feature_version < 5) { ast_error(c, n, "Async functions are only supported in Python 3.5 and greater"); return NULL; } REQ(n, funcdef); name = NEW_IDENTIFIER(CHILD(n, name_i)); if (!name) return NULL; if (forbidden_name(c, name, CHILD(n, name_i), 0)) return NULL; args = ast_for_arguments(c, CHILD(n, name_i + 1)); if (!args) return NULL; if (TYPE(CHILD(n, name_i+2)) == RARROW) { returns = ast_for_expr(c, CHILD(n, name_i + 3)); if (!returns) return NULL; name_i += 2; } if (TYPE(CHILD(n, name_i + 3)) == TYPE_COMMENT) { type_comment = NEW_TYPE_COMMENT(CHILD(n, name_i + 3)); name_i += 1; } body = ast_for_suite(c, CHILD(n, name_i + 3)); if (!body) return NULL; if (!type_comment && NCH(CHILD(n, name_i + 3)) > 1) { /* If the function doesn't have a type comment on the same line, check * if the suite has a type comment in it. */ tc = CHILD(CHILD(n, name_i + 3), 1); if (TYPE(tc) == TYPE_COMMENT) type_comment = NEW_TYPE_COMMENT(tc); } if (is_async) return AsyncFunctionDef(name, args, body, decorator_seq, returns, type_comment, LINENO(n), n->n_col_offset, c->c_arena); else return FunctionDef(name, args, body, decorator_seq, returns, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_async_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) { /* async_funcdef: ASYNC funcdef */ REQ(n, async_funcdef); REQ(CHILD(n, 0), ASYNC); REQ(CHILD(n, 1), funcdef); return ast_for_funcdef_impl(c, CHILD(n, 1), decorator_seq, 1 /* is_async */); } static stmt_ty ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) { /* funcdef: 'def' NAME parameters ['->' test] ':' suite */ return ast_for_funcdef_impl(c, n, decorator_seq, 0 /* is_async */); } static stmt_ty ast_for_async_stmt(struct compiling *c, const node *n) { /* async_stmt: ASYNC (funcdef | with_stmt | for_stmt) */ REQ(n, async_stmt); REQ(CHILD(n, 0), ASYNC); switch (TYPE(CHILD(n, 1))) { case funcdef: return ast_for_funcdef_impl(c, CHILD(n, 1), NULL, 1 /* is_async */); case with_stmt: return ast_for_with_stmt(c, CHILD(n, 1), 1 /* is_async */); case for_stmt: return ast_for_for_stmt(c, CHILD(n, 1), 1 /* is_async */); default: PyErr_Format(PyExc_SystemError, "invalid async stament: %s", STR(CHILD(n, 1))); return NULL; } } static stmt_ty ast_for_decorated(struct compiling *c, const node *n) { /* decorated: decorators (classdef | funcdef | async_funcdef) */ stmt_ty thing = NULL; asdl_seq *decorator_seq = NULL; REQ(n, decorated); decorator_seq = ast_for_decorators(c, CHILD(n, 0)); if (!decorator_seq) return NULL; assert(TYPE(CHILD(n, 1)) == funcdef || TYPE(CHILD(n, 1)) == async_funcdef || TYPE(CHILD(n, 1)) == classdef); if (TYPE(CHILD(n, 1)) == funcdef) { thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq); } else if (TYPE(CHILD(n, 1)) == classdef) { thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq); } else if (TYPE(CHILD(n, 1)) == async_funcdef) { thing = ast_for_async_funcdef(c, CHILD(n, 1), decorator_seq); } /* we count the decorators in when talking about the class' or * function's line number */ if (thing) { thing->lineno = LINENO(n); thing->col_offset = n->n_col_offset; } return thing; } static expr_ty ast_for_lambdef(struct compiling *c, const node *n) { /* lambdef: 'lambda' [varargslist] ':' test lambdef_nocond: 'lambda' [varargslist] ':' test_nocond */ arguments_ty args; expr_ty expression; if (NCH(n) == 3) { args = arguments(NULL, NULL, NULL, NULL, NULL, NULL, c->c_arena); if (!args) return NULL; expression = ast_for_expr(c, CHILD(n, 2)); if (!expression) return NULL; } else { args = ast_for_arguments(c, CHILD(n, 1)); if (!args) return NULL; expression = ast_for_expr(c, CHILD(n, 3)); if (!expression) return NULL; } return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_ifexpr(struct compiling *c, const node *n) { /* test: or_test 'if' or_test 'else' test */ expr_ty expression, body, orelse; assert(NCH(n) == 5); body = ast_for_expr(c, CHILD(n, 0)); if (!body) return NULL; expression = ast_for_expr(c, CHILD(n, 2)); if (!expression) return NULL; orelse = ast_for_expr(c, CHILD(n, 4)); if (!orelse) return NULL; return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset, c->c_arena); } /* Count the number of 'for' loops in a comprehension. Helper for ast_for_comprehension(). */ static int count_comp_fors(struct compiling *c, const node *n) { int n_fors = 0; int is_async; count_comp_for: is_async = 0; n_fors++; REQ(n, comp_for); if (TYPE(CHILD(n, 0)) == ASYNC) { is_async = 1; } if (NCH(n) == (5 + is_async)) { n = CHILD(n, 4 + is_async); } else { return n_fors; } count_comp_iter: REQ(n, comp_iter); n = CHILD(n, 0); if (TYPE(n) == comp_for) goto count_comp_for; else if (TYPE(n) == comp_if) { if (NCH(n) == 3) { n = CHILD(n, 2); goto count_comp_iter; } else return n_fors; } /* Should never be reached */ PyErr_SetString(PyExc_SystemError, "logic error in count_comp_fors"); return -1; } /* Count the number of 'if' statements in a comprehension. Helper for ast_for_comprehension(). */ static int count_comp_ifs(struct compiling *c, const node *n) { int n_ifs = 0; while (1) { REQ(n, comp_iter); if (TYPE(CHILD(n, 0)) == comp_for) return n_ifs; n = CHILD(n, 0); REQ(n, comp_if); n_ifs++; if (NCH(n) == 2) return n_ifs; n = CHILD(n, 2); } } static asdl_seq * ast_for_comprehension(struct compiling *c, const node *n) { int i, n_fors; asdl_seq *comps; n_fors = count_comp_fors(c, n); if (n_fors == -1) return NULL; comps = _Ta3_asdl_seq_new(n_fors, c->c_arena); if (!comps) return NULL; for (i = 0; i < n_fors; i++) { comprehension_ty comp; asdl_seq *t; expr_ty expression, first; node *for_ch; int is_async = 0; REQ(n, comp_for); if (TYPE(CHILD(n, 0)) == ASYNC) { is_async = 1; } /* Async comprehensions only allowed in Python 3.6 and greater */ if (is_async && c->c_feature_version < 6) { ast_error(c, n, "Async comprehensions are only supported in Python 3.6 and greater"); return NULL; } for_ch = CHILD(n, 1 + is_async); t = ast_for_exprlist(c, for_ch, Store); if (!t) return NULL; expression = ast_for_expr(c, CHILD(n, 3 + is_async)); if (!expression) return NULL; /* Check the # of children rather than the length of t, since (x for x, in ...) has 1 element in t, but still requires a Tuple. */ first = (expr_ty)asdl_seq_GET(t, 0); if (NCH(for_ch) == 1) comp = comprehension(first, expression, NULL, is_async, c->c_arena); else comp = comprehension(Tuple(t, Store, first->lineno, first->col_offset, c->c_arena), expression, NULL, is_async, c->c_arena); if (!comp) return NULL; if (NCH(n) == (5 + is_async)) { int j, n_ifs; asdl_seq *ifs; n = CHILD(n, 4 + is_async); n_ifs = count_comp_ifs(c, n); if (n_ifs == -1) return NULL; ifs = _Ta3_asdl_seq_new(n_ifs, c->c_arena); if (!ifs) return NULL; for (j = 0; j < n_ifs; j++) { REQ(n, comp_iter); n = CHILD(n, 0); REQ(n, comp_if); expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; asdl_seq_SET(ifs, j, expression); if (NCH(n) == 3) n = CHILD(n, 2); } /* on exit, must guarantee that n is a comp_for */ if (TYPE(n) == comp_iter) n = CHILD(n, 0); comp->ifs = ifs; } asdl_seq_SET(comps, i, comp); } return comps; } static expr_ty ast_for_itercomp(struct compiling *c, const node *n, int type) { /* testlist_comp: (test|star_expr) * ( comp_for | (',' (test|star_expr))* [','] ) */ expr_ty elt; asdl_seq *comps; node *ch; assert(NCH(n) > 1); ch = CHILD(n, 0); elt = ast_for_expr(c, ch); if (!elt) return NULL; if (elt->kind == Starred_kind) { ast_error(c, ch, "iterable unpacking cannot be used in comprehension"); return NULL; } comps = ast_for_comprehension(c, CHILD(n, 1)); if (!comps) return NULL; if (type == COMP_GENEXP) return GeneratorExp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena); else if (type == COMP_LISTCOMP) return ListComp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena); else if (type == COMP_SETCOMP) return SetComp(elt, comps, LINENO(n), n->n_col_offset, c->c_arena); else /* Should never happen */ return NULL; } /* Fills in the key, value pair corresponding to the dict element. In case * of an unpacking, key is NULL. *i is advanced by the number of ast * elements. Iff successful, nonzero is returned. */ static int ast_for_dictelement(struct compiling *c, const node *n, int *i, expr_ty *key, expr_ty *value) { expr_ty expression; if (TYPE(CHILD(n, *i)) == DOUBLESTAR) { assert(NCH(n) - *i >= 2); expression = ast_for_expr(c, CHILD(n, *i + 1)); if (!expression) return 0; *key = NULL; *value = expression; *i += 2; } else { assert(NCH(n) - *i >= 3); expression = ast_for_expr(c, CHILD(n, *i)); if (!expression) return 0; *key = expression; REQ(CHILD(n, *i + 1), COLON); expression = ast_for_expr(c, CHILD(n, *i + 2)); if (!expression) return 0; *value = expression; *i += 3; } return 1; } static expr_ty ast_for_dictcomp(struct compiling *c, const node *n) { expr_ty key, value; asdl_seq *comps; int i = 0; if (!ast_for_dictelement(c, n, &i, &key, &value)) return NULL; assert(key); assert(NCH(n) - i >= 1); comps = ast_for_comprehension(c, CHILD(n, i)); if (!comps) return NULL; return DictComp(key, value, comps, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_dictdisplay(struct compiling *c, const node *n) { int i; int j; int size; asdl_seq *keys, *values; size = (NCH(n) + 1) / 3; /* +1 in case no trailing comma */ keys = _Ta3_asdl_seq_new(size, c->c_arena); if (!keys) return NULL; values = _Ta3_asdl_seq_new(size, c->c_arena); if (!values) return NULL; j = 0; for (i = 0; i < NCH(n); i++) { expr_ty key, value; if (!ast_for_dictelement(c, n, &i, &key, &value)) return NULL; asdl_seq_SET(keys, j, key); asdl_seq_SET(values, j, value); j++; } keys->size = j; values->size = j; return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_genexp(struct compiling *c, const node *n) { assert(TYPE(n) == (testlist_comp) || TYPE(n) == (argument)); return ast_for_itercomp(c, n, COMP_GENEXP); } static expr_ty ast_for_listcomp(struct compiling *c, const node *n) { assert(TYPE(n) == (testlist_comp)); return ast_for_itercomp(c, n, COMP_LISTCOMP); } static expr_ty ast_for_setcomp(struct compiling *c, const node *n) { assert(TYPE(n) == (dictorsetmaker)); return ast_for_itercomp(c, n, COMP_SETCOMP); } static expr_ty ast_for_setdisplay(struct compiling *c, const node *n) { int i; int size; asdl_seq *elts; assert(TYPE(n) == (dictorsetmaker)); size = (NCH(n) + 1) / 2; /* +1 in case no trailing comma */ elts = _Ta3_asdl_seq_new(size, c->c_arena); if (!elts) return NULL; for (i = 0; i < NCH(n); i += 2) { expr_ty expression; expression = ast_for_expr(c, CHILD(n, i)); if (!expression) return NULL; asdl_seq_SET(elts, i / 2, expression); } return Set(elts, LINENO(n), n->n_col_offset, c->c_arena); } static expr_ty ast_for_atom(struct compiling *c, const node *n) { /* atom: '(' [yield_expr|testlist_comp] ')' | '[' [testlist_comp] ']' | '{' [dictmaker|testlist_comp] '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False' */ node *ch = CHILD(n, 0); switch (TYPE(ch)) { case NAME: { PyObject *name; const char *s = STR(ch); size_t len = strlen(s); if (len >= 4 && len <= 5) { if (!strcmp(s, "None")) return NameConstant(Py_None, LINENO(n), n->n_col_offset, c->c_arena); if (!strcmp(s, "True")) return NameConstant(Py_True, LINENO(n), n->n_col_offset, c->c_arena); if (!strcmp(s, "False")) return NameConstant(Py_False, LINENO(n), n->n_col_offset, c->c_arena); } name = new_identifier(s, c); if (!name) return NULL; /* All names start in Load context, but may later be changed. */ return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena); } case STRING: { expr_ty str = parsestrplus(c, n); if (!str) { const char *errtype = NULL; if (PyErr_ExceptionMatches(PyExc_UnicodeError)) errtype = "unicode error"; else if (PyErr_ExceptionMatches(PyExc_ValueError)) errtype = "value error"; if (errtype) { char buf[128]; const char *s = NULL; PyObject *type, *value, *tback, *errstr; PyErr_Fetch(&type, &value, &tback); errstr = PyObject_Str(value); if (errstr) s = PyUnicode_AsUTF8(errstr); if (s) { PyOS_snprintf(buf, sizeof(buf), "(%s) %s", errtype, s); } else { PyErr_Clear(); PyOS_snprintf(buf, sizeof(buf), "(%s) unknown error", errtype); } Py_XDECREF(errstr); ast_error(c, n, buf); Py_DECREF(type); Py_XDECREF(value); Py_XDECREF(tback); } return NULL; } return str; } case NUMBER: { PyObject *pynum; const char *s = STR(ch); /* Underscores in numeric literals are only allowed in Python 3.6 or greater */ /* Check for underscores here rather than in parse_number so we can report a line number on error */ if (c->c_feature_version < 6 && strchr(s, '_') != NULL) { ast_error(c, ch, "Underscores in numeric literals are only supported in Python 3.6 and greater"); return NULL; } pynum = parsenumber(c, s); if (!pynum) return NULL; if (PyArena_AddPyObject(c->c_arena, pynum) < 0) { Py_DECREF(pynum); return NULL; } return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena); } case ELLIPSIS: /* Ellipsis */ return Ellipsis(LINENO(n), n->n_col_offset, c->c_arena); case LPAR: /* some parenthesized expressions */ ch = CHILD(n, 1); if (TYPE(ch) == RPAR) return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena); if (TYPE(ch) == yield_expr) return ast_for_expr(c, ch); /* testlist_comp: test ( comp_for | (',' test)* [','] ) */ if ((NCH(ch) > 1) && (TYPE(CHILD(ch, 1)) == comp_for)) return ast_for_genexp(c, ch); return ast_for_testlist(c, ch); case LSQB: /* list (or list comprehension) */ ch = CHILD(n, 1); if (TYPE(ch) == RSQB) return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena); REQ(ch, testlist_comp); if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) { asdl_seq *elts = seq_for_testlist(c, ch); if (!elts) return NULL; return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena); } else return ast_for_listcomp(c, ch); case LBRACE: { /* dictorsetmaker: ( ((test ':' test | '**' test) * (comp_for | (',' (test ':' test | '**' test))* [','])) | * ((test | '*' test) * (comp_for | (',' (test | '*' test))* [','])) ) */ expr_ty res; ch = CHILD(n, 1); if (TYPE(ch) == RBRACE) { /* It's an empty dict. */ return Dict(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else { int is_dict = (TYPE(CHILD(ch, 0)) == DOUBLESTAR); if (NCH(ch) == 1 || (NCH(ch) > 1 && TYPE(CHILD(ch, 1)) == COMMA)) { /* It's a set display. */ res = ast_for_setdisplay(c, ch); } else if (NCH(ch) > 1 && TYPE(CHILD(ch, 1)) == comp_for) { /* It's a set comprehension. */ res = ast_for_setcomp(c, ch); } else if (NCH(ch) > 3 - is_dict && TYPE(CHILD(ch, 3 - is_dict)) == comp_for) { /* It's a dictionary comprehension. */ if (is_dict) { ast_error(c, n, "dict unpacking cannot be used in " "dict comprehension"); return NULL; } res = ast_for_dictcomp(c, ch); } else { /* It's a dictionary display. */ res = ast_for_dictdisplay(c, ch); } if (res) { res->lineno = LINENO(n); res->col_offset = n->n_col_offset; } return res; } } default: PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch)); return NULL; } } static slice_ty ast_for_slice(struct compiling *c, const node *n) { node *ch; expr_ty lower = NULL, upper = NULL, step = NULL; REQ(n, subscript); /* subscript: test | [test] ':' [test] [sliceop] sliceop: ':' [test] */ ch = CHILD(n, 0); if (NCH(n) == 1 && TYPE(ch) == test) { /* 'step' variable hold no significance in terms of being used over other vars */ step = ast_for_expr(c, ch); if (!step) return NULL; return Index(step, c->c_arena); } if (TYPE(ch) == test) { lower = ast_for_expr(c, ch); if (!lower) return NULL; } /* If there's an upper bound it's in the second or third position. */ if (TYPE(ch) == COLON) { if (NCH(n) > 1) { node *n2 = CHILD(n, 1); if (TYPE(n2) == test) { upper = ast_for_expr(c, n2); if (!upper) return NULL; } } } else if (NCH(n) > 2) { node *n2 = CHILD(n, 2); if (TYPE(n2) == test) { upper = ast_for_expr(c, n2); if (!upper) return NULL; } } ch = CHILD(n, NCH(n) - 1); if (TYPE(ch) == sliceop) { if (NCH(ch) != 1) { ch = CHILD(ch, 1); if (TYPE(ch) == test) { step = ast_for_expr(c, ch); if (!step) return NULL; } } } return Slice(lower, upper, step, c->c_arena); } static expr_ty ast_for_binop(struct compiling *c, const node *n) { /* Must account for a sequence of expressions. How should A op B op C by represented? BinOp(BinOp(A, op, B), op, C). */ int i, nops; expr_ty expr1, expr2, result; operator_ty newoperator; expr1 = ast_for_expr(c, CHILD(n, 0)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(n, 2)); if (!expr2) return NULL; newoperator = get_operator(c, CHILD(n, 1)); if (!newoperator) return NULL; result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset, c->c_arena); if (!result) return NULL; nops = (NCH(n) - 1) / 2; for (i = 1; i < nops; i++) { expr_ty tmp_result, tmp; const node* next_oper = CHILD(n, i * 2 + 1); newoperator = get_operator(c, next_oper); if (!newoperator) return NULL; tmp = ast_for_expr(c, CHILD(n, i * 2 + 2)); if (!tmp) return NULL; tmp_result = BinOp(result, newoperator, tmp, LINENO(next_oper), next_oper->n_col_offset, c->c_arena); if (!tmp_result) return NULL; result = tmp_result; } return result; } static expr_ty ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr) { /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME subscriptlist: subscript (',' subscript)* [','] subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] */ REQ(n, trailer); if (TYPE(CHILD(n, 0)) == LPAR) { if (NCH(n) == 2) return Call(left_expr, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); else return ast_for_call(c, CHILD(n, 1), left_expr); } else if (TYPE(CHILD(n, 0)) == DOT) { PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1)); if (!attr_id) return NULL; return Attribute(left_expr, attr_id, Load, LINENO(n), n->n_col_offset, c->c_arena); } else { REQ(CHILD(n, 0), LSQB); REQ(CHILD(n, 2), RSQB); n = CHILD(n, 1); if (NCH(n) == 1) { slice_ty slc = ast_for_slice(c, CHILD(n, 0)); if (!slc) return NULL; return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset, c->c_arena); } else { /* The grammar is ambiguous here. The ambiguity is resolved by treating the sequence as a tuple literal if there are no slice features. */ int j; slice_ty slc; expr_ty e; int simple = 1; asdl_seq *slices, *elts; slices = _Ta3_asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!slices) return NULL; for (j = 0; j < NCH(n); j += 2) { slc = ast_for_slice(c, CHILD(n, j)); if (!slc) return NULL; if (slc->kind != Index_kind) simple = 0; asdl_seq_SET(slices, j / 2, slc); } if (!simple) { return Subscript(left_expr, ExtSlice(slices, c->c_arena), Load, LINENO(n), n->n_col_offset, c->c_arena); } /* extract Index values and put them in a Tuple */ elts = _Ta3_asdl_seq_new(asdl_seq_LEN(slices), c->c_arena); if (!elts) return NULL; for (j = 0; j < asdl_seq_LEN(slices); ++j) { slc = (slice_ty)asdl_seq_GET(slices, j); assert(slc->kind == Index_kind && slc->v.Index.value); asdl_seq_SET(elts, j, slc->v.Index.value); } e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena); if (!e) return NULL; return Subscript(left_expr, Index(e, c->c_arena), Load, LINENO(n), n->n_col_offset, c->c_arena); } } } static expr_ty ast_for_factor(struct compiling *c, const node *n) { expr_ty expression; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; switch (TYPE(CHILD(n, 0))) { case PLUS: return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset, c->c_arena); case MINUS: return UnaryOp(USub, expression, LINENO(n), n->n_col_offset, c->c_arena); case TILDE: return UnaryOp(Invert, expression, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unhandled factor: %d", TYPE(CHILD(n, 0))); return NULL; } static expr_ty ast_for_atom_expr(struct compiling *c, const node *n) { int i, nch, start = 0; expr_ty e, tmp; REQ(n, atom_expr); nch = NCH(n); if (TYPE(CHILD(n, 0)) == AWAIT) { if (c->c_feature_version < 5) { ast_error(c, n, "Await expressions are only supported in Python 3.5 and greater"); return NULL; } start = 1; assert(nch > 1); } e = ast_for_atom(c, CHILD(n, start)); if (!e) return NULL; if (nch == 1) return e; if (start && nch == 2) { return Await(e, LINENO(n), n->n_col_offset, c->c_arena); } for (i = start + 1; i < nch; i++) { node *ch = CHILD(n, i); if (TYPE(ch) != trailer) break; tmp = ast_for_trailer(c, ch, e); if (!tmp) return NULL; tmp->lineno = e->lineno; tmp->col_offset = e->col_offset; e = tmp; } if (start) { /* there was an AWAIT */ return Await(e, LINENO(n), n->n_col_offset, c->c_arena); } else { return e; } } static expr_ty ast_for_power(struct compiling *c, const node *n) { /* power: atom trailer* ('**' factor)* */ expr_ty e; REQ(n, power); e = ast_for_atom_expr(c, CHILD(n, 0)); if (!e) return NULL; if (NCH(n) == 1) return e; if (TYPE(CHILD(n, NCH(n) - 1)) == factor) { expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1)); if (!f) return NULL; e = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena); } return e; } static expr_ty ast_for_starred(struct compiling *c, const node *n) { expr_ty tmp; REQ(n, star_expr); tmp = ast_for_expr(c, CHILD(n, 1)); if (!tmp) return NULL; /* The Load context is changed later. */ return Starred(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena); } /* Do not name a variable 'expr'! Will cause a compile error. */ static expr_ty ast_for_expr(struct compiling *c, const node *n) { /* handle the full range of simple expressions test: or_test ['if' or_test 'else' test] | lambdef test_nocond: or_test | lambdef_nocond or_test: and_test ('or' and_test)* and_test: not_test ('and' not_test)* not_test: 'not' not_test | comparison comparison: expr (comp_op expr)* expr: xor_expr ('|' xor_expr)* xor_expr: and_expr ('^' and_expr)* and_expr: shift_expr ('&' shift_expr)* shift_expr: arith_expr (('<<'|'>>') arith_expr)* arith_expr: term (('+'|'-') term)* term: factor (('*'|'@'|'/'|'%'|'//') factor)* factor: ('+'|'-'|'~') factor | power power: atom_expr ['**' factor] atom_expr: [AWAIT] atom trailer* yield_expr: 'yield' [yield_arg] */ asdl_seq *seq; int i; loop: switch (TYPE(n)) { case test: case test_nocond: if (TYPE(CHILD(n, 0)) == lambdef || TYPE(CHILD(n, 0)) == lambdef_nocond) return ast_for_lambdef(c, CHILD(n, 0)); else if (NCH(n) > 1) return ast_for_ifexpr(c, n); /* Fallthrough */ case or_test: case and_test: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } seq = _Ta3_asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { expr_ty e = ast_for_expr(c, CHILD(n, i)); if (!e) return NULL; asdl_seq_SET(seq, i / 2, e); } if (!strcmp(STR(CHILD(n, 1)), "and")) return BoolOp(And, seq, LINENO(n), n->n_col_offset, c->c_arena); assert(!strcmp(STR(CHILD(n, 1)), "or")); return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena); case not_test: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { expr_ty expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; return UnaryOp(Not, expression, LINENO(n), n->n_col_offset, c->c_arena); } case comparison: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { expr_ty expression; asdl_int_seq *ops; asdl_seq *cmps; ops = _Ta3_asdl_int_seq_new(NCH(n) / 2, c->c_arena); if (!ops) return NULL; cmps = _Ta3_asdl_seq_new(NCH(n) / 2, c->c_arena); if (!cmps) { return NULL; } for (i = 1; i < NCH(n); i += 2) { cmpop_ty newoperator; newoperator = ast_for_comp_op(c, CHILD(n, i)); if (!newoperator) { return NULL; } expression = ast_for_expr(c, CHILD(n, i + 1)); if (!expression) { return NULL; } asdl_seq_SET(ops, i / 2, newoperator); asdl_seq_SET(cmps, i / 2, expression); } expression = ast_for_expr(c, CHILD(n, 0)); if (!expression) { return NULL; } return Compare(expression, ops, cmps, LINENO(n), n->n_col_offset, c->c_arena); } break; case star_expr: return ast_for_starred(c, n); /* The next five cases all handle BinOps. The main body of code is the same in each case, but the switch turned inside out to reuse the code for each type of operator. */ case expr: case xor_expr: case and_expr: case shift_expr: case arith_expr: case term: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } return ast_for_binop(c, n); case yield_expr: { node *an = NULL; node *en = NULL; int is_from = 0; expr_ty exp = NULL; if (NCH(n) > 1) an = CHILD(n, 1); /* yield_arg */ if (an) { en = CHILD(an, NCH(an) - 1); if (NCH(an) == 2) { is_from = 1; exp = ast_for_expr(c, en); } else exp = ast_for_testlist(c, en); if (!exp) return NULL; } if (is_from) return YieldFrom(exp, LINENO(n), n->n_col_offset, c->c_arena); return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena); } case factor: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } return ast_for_factor(c, n); case power: return ast_for_power(c, n); default: PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n)); return NULL; } /* should never get here unless if error is set */ return NULL; } static expr_ty ast_for_call(struct compiling *c, const node *n, expr_ty func) { /* arglist: argument (',' argument)* [','] argument: ( test [comp_for] | '*' test | test '=' test | '**' test ) */ int i, nargs, nkeywords, ngens; int ndoublestars; asdl_seq *args; asdl_seq *keywords; REQ(n, arglist); nargs = 0; nkeywords = 0; ngens = 0; for (i = 0; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) == argument) { if (NCH(ch) == 1) nargs++; else if (TYPE(CHILD(ch, 1)) == comp_for) ngens++; else if (TYPE(CHILD(ch, 0)) == STAR) nargs++; else /* TYPE(CHILD(ch, 0)) == DOUBLESTAR or keyword argument */ nkeywords++; } } if (ngens > 1 || (ngens && (nargs || nkeywords))) { ast_error(c, n, "Generator expression must be parenthesized " "if not sole argument"); return NULL; } if (nargs + nkeywords + ngens > 255) { ast_error(c, n, "more than 255 arguments"); return NULL; } args = _Ta3_asdl_seq_new(nargs + ngens, c->c_arena); if (!args) return NULL; keywords = _Ta3_asdl_seq_new(nkeywords, c->c_arena); if (!keywords) return NULL; nargs = 0; /* positional arguments + iterable argument unpackings */ nkeywords = 0; /* keyword arguments + keyword argument unpackings */ ndoublestars = 0; /* just keyword argument unpackings */ for (i = 0; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) == argument) { expr_ty e; node *chch = CHILD(ch, 0); if (NCH(ch) == 1) { /* a positional argument */ if (nkeywords) { if (ndoublestars) { ast_error(c, chch, "positional argument follows " "keyword argument unpacking"); } else { ast_error(c, chch, "positional argument follows " "keyword argument"); } return NULL; } e = ast_for_expr(c, chch); if (!e) return NULL; asdl_seq_SET(args, nargs++, e); } else if (TYPE(chch) == STAR) { /* an iterable argument unpacking */ expr_ty starred; if (ndoublestars) { ast_error(c, chch, "iterable argument unpacking follows " "keyword argument unpacking"); return NULL; } e = ast_for_expr(c, CHILD(ch, 1)); if (!e) return NULL; starred = Starred(e, Load, LINENO(chch), chch->n_col_offset, c->c_arena); if (!starred) return NULL; asdl_seq_SET(args, nargs++, starred); } else if (TYPE(chch) == DOUBLESTAR) { /* a keyword argument unpacking */ keyword_ty kw; i++; e = ast_for_expr(c, CHILD(ch, 1)); if (!e) return NULL; kw = keyword(NULL, e, c->c_arena); asdl_seq_SET(keywords, nkeywords++, kw); ndoublestars++; } else if (TYPE(CHILD(ch, 1)) == comp_for) { /* the lone generator expression */ e = ast_for_genexp(c, ch); if (!e) return NULL; asdl_seq_SET(args, nargs++, e); } else { /* a keyword argument */ keyword_ty kw; identifier key, tmp; int k; /* chch is test, but must be an identifier? */ e = ast_for_expr(c, chch); if (!e) return NULL; /* f(lambda x: x[0] = 3) ends up getting parsed with * LHS test = lambda x: x[0], and RHS test = 3. * SF bug 132313 points out that complaining about a keyword * then is very confusing. */ if (e->kind == Lambda_kind) { ast_error(c, chch, "lambda cannot contain assignment"); return NULL; } else if (e->kind != Name_kind) { ast_error(c, chch, "keyword can't be an expression"); return NULL; } else if (forbidden_name(c, e->v.Name.id, ch, 1)) { return NULL; } key = e->v.Name.id; for (k = 0; k < nkeywords; k++) { tmp = ((keyword_ty)asdl_seq_GET(keywords, k))->arg; if (tmp && !PyUnicode_Compare(tmp, key)) { ast_error(c, chch, "keyword argument repeated"); return NULL; } } e = ast_for_expr(c, CHILD(ch, 2)); if (!e) return NULL; kw = keyword(key, e, c->c_arena); if (!kw) return NULL; asdl_seq_SET(keywords, nkeywords++, kw); } } } return Call(func, args, keywords, func->lineno, func->col_offset, c->c_arena); } static expr_ty ast_for_testlist(struct compiling *c, const node* n) { /* testlist_comp: test (comp_for | (',' test)* [',']) */ /* testlist: test (',' test)* [','] */ assert(NCH(n) > 0); if (TYPE(n) == testlist_comp) { if (NCH(n) > 1) assert(TYPE(CHILD(n, 1)) != comp_for); } else { assert(TYPE(n) == testlist || TYPE(n) == testlist_star_expr); } if (NCH(n) == 1) return ast_for_expr(c, CHILD(n, 0)); else { asdl_seq *tmp = seq_for_testlist(c, n); if (!tmp) return NULL; return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena); } } static stmt_ty ast_for_expr_stmt(struct compiling *c, const node *n) { int num; REQ(n, expr_stmt); /* expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))* [TYPE_COMMENT]) annassign: ':' test ['=' test] testlist_star_expr: (test|star_expr) (',' test|star_expr)* [','] augassign: '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' test: ... here starts the operator precedence dance */ num = NCH(n); if (num == 1 || (num == 2 && TYPE(CHILD(n, 1)) == TYPE_COMMENT)) { expr_ty e = ast_for_testlist(c, CHILD(n, 0)); if (!e) return NULL; return Expr(e, LINENO(n), n->n_col_offset, c->c_arena); } else if (TYPE(CHILD(n, 1)) == augassign) { expr_ty expr1, expr2; operator_ty newoperator; node *ch = CHILD(n, 0); expr1 = ast_for_testlist(c, ch); if (!expr1) return NULL; if(!set_context(c, expr1, Store, ch)) return NULL; /* set_context checks that most expressions are not the left side. Augmented assignments can only have a name, a subscript, or an attribute on the left, though, so we have to explicitly check for those. */ switch (expr1->kind) { case Name_kind: case Attribute_kind: case Subscript_kind: break; default: ast_error(c, ch, "illegal expression for augmented assignment"); return NULL; } ch = CHILD(n, 2); if (TYPE(ch) == testlist) expr2 = ast_for_testlist(c, ch); else expr2 = ast_for_expr(c, ch); if (!expr2) return NULL; newoperator = ast_for_augassign(c, CHILD(n, 1)); if (!newoperator) return NULL; return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset, c->c_arena); } else if (TYPE(CHILD(n, 1)) == annassign) { expr_ty expr1, expr2, expr3; node *ch = CHILD(n, 0); node *deep, *ann = CHILD(n, 1); int simple = 1; /* AnnAssigns are only allowed in Python 3.6 or greater */ if (c->c_feature_version < 6) { ast_error(c, ch, "Variable annotation syntax is only supported in Python 3.6 and greater"); return NULL; } /* we keep track of parens to qualify (x) as expression not name */ deep = ch; while (NCH(deep) == 1) { deep = CHILD(deep, 0); } if (NCH(deep) > 0 && TYPE(CHILD(deep, 0)) == LPAR) { simple = 0; } expr1 = ast_for_testlist(c, ch); if (!expr1) { return NULL; } switch (expr1->kind) { case Name_kind: if (forbidden_name(c, expr1->v.Name.id, n, 0)) { return NULL; } expr1->v.Name.ctx = Store; break; case Attribute_kind: if (forbidden_name(c, expr1->v.Attribute.attr, n, 1)) { return NULL; } expr1->v.Attribute.ctx = Store; break; case Subscript_kind: expr1->v.Subscript.ctx = Store; break; case List_kind: ast_error(c, ch, "only single target (not list) can be annotated"); return NULL; case Tuple_kind: ast_error(c, ch, "only single target (not tuple) can be annotated"); return NULL; default: ast_error(c, ch, "illegal target for annotation"); return NULL; } if (expr1->kind != Name_kind) { simple = 0; } ch = CHILD(ann, 1); expr2 = ast_for_expr(c, ch); if (!expr2) { return NULL; } if (NCH(ann) == 2) { return AnnAssign(expr1, expr2, NULL, simple, LINENO(n), n->n_col_offset, c->c_arena); } else { ch = CHILD(ann, 3); expr3 = ast_for_expr(c, ch); if (!expr3) { return NULL; } return AnnAssign(expr1, expr2, expr3, simple, LINENO(n), n->n_col_offset, c->c_arena); } } else { int i, nch_minus_type, has_type_comment; asdl_seq *targets; node *value; expr_ty expression; string type_comment; /* a normal assignment */ REQ(CHILD(n, 1), EQUAL); has_type_comment = TYPE(CHILD(n, num - 1)) == TYPE_COMMENT; nch_minus_type = num - has_type_comment; targets = _Ta3_asdl_seq_new(nch_minus_type / 2, c->c_arena); if (!targets) return NULL; for (i = 0; i < nch_minus_type - 2; i += 2) { expr_ty e; node *ch = CHILD(n, i); if (TYPE(ch) == yield_expr) { ast_error(c, ch, "assignment to yield expression not possible"); return NULL; } e = ast_for_testlist(c, ch); if (!e) return NULL; /* set context to assign */ if (!set_context(c, e, Store, CHILD(n, i))) return NULL; asdl_seq_SET(targets, i / 2, e); } value = CHILD(n, nch_minus_type - 1); if (TYPE(value) == testlist_star_expr) expression = ast_for_testlist(c, value); else expression = ast_for_expr(c, value); if (!expression) return NULL; if (has_type_comment) type_comment = NEW_TYPE_COMMENT(CHILD(n, nch_minus_type)); else type_comment = NULL; return Assign(targets, expression, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } } static asdl_seq * ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context) { asdl_seq *seq; int i; expr_ty e; REQ(n, exprlist); seq = _Ta3_asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!seq) return NULL; for (i = 0; i < NCH(n); i += 2) { e = ast_for_expr(c, CHILD(n, i)); if (!e) return NULL; asdl_seq_SET(seq, i / 2, e); if (context && !set_context(c, e, context, CHILD(n, i))) return NULL; } return seq; } static stmt_ty ast_for_del_stmt(struct compiling *c, const node *n) { asdl_seq *expr_list; /* del_stmt: 'del' exprlist */ REQ(n, del_stmt); expr_list = ast_for_exprlist(c, CHILD(n, 1), Del); if (!expr_list) return NULL; return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_flow_stmt(struct compiling *c, const node *n) { /* flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt break_stmt: 'break' continue_stmt: 'continue' return_stmt: 'return' [testlist] yield_stmt: yield_expr yield_expr: 'yield' testlist | 'yield' 'from' test raise_stmt: 'raise' [test [',' test [',' test]]] */ node *ch; REQ(n, flow_stmt); ch = CHILD(n, 0); switch (TYPE(ch)) { case break_stmt: return Break(LINENO(n), n->n_col_offset, c->c_arena); case continue_stmt: return Continue(LINENO(n), n->n_col_offset, c->c_arena); case yield_stmt: { /* will reduce to yield_expr */ expr_ty exp = ast_for_expr(c, CHILD(ch, 0)); if (!exp) return NULL; return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena); } case return_stmt: if (NCH(ch) == 1) return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena); else { expr_ty expression = ast_for_testlist(c, CHILD(ch, 1)); if (!expression) return NULL; return Return(expression, LINENO(n), n->n_col_offset, c->c_arena); } case raise_stmt: if (NCH(ch) == 1) return Raise(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); else if (NCH(ch) >= 2) { expr_ty cause = NULL; expr_ty expression = ast_for_expr(c, CHILD(ch, 1)); if (!expression) return NULL; if (NCH(ch) == 4) { cause = ast_for_expr(c, CHILD(ch, 3)); if (!cause) return NULL; } return Raise(expression, cause, LINENO(n), n->n_col_offset, c->c_arena); } default: PyErr_Format(PyExc_SystemError, "unexpected flow_stmt: %d", TYPE(ch)); return NULL; } } static alias_ty alias_for_import_name(struct compiling *c, const node *n, int store) { /* import_as_name: NAME ['as' NAME] dotted_as_name: dotted_name ['as' NAME] dotted_name: NAME ('.' NAME)* */ identifier str, name; loop: switch (TYPE(n)) { case import_as_name: { node *name_node = CHILD(n, 0); str = NULL; name = NEW_IDENTIFIER(name_node); if (!name) return NULL; if (NCH(n) == 3) { node *str_node = CHILD(n, 2); str = NEW_IDENTIFIER(str_node); if (!str) return NULL; if (store && forbidden_name(c, str, str_node, 0)) return NULL; } else { if (forbidden_name(c, name, name_node, 0)) return NULL; } return alias(name, str, c->c_arena); } case dotted_as_name: if (NCH(n) == 1) { n = CHILD(n, 0); goto loop; } else { node *asname_node = CHILD(n, 2); alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0); if (!a) return NULL; assert(!a->asname); a->asname = NEW_IDENTIFIER(asname_node); if (!a->asname) return NULL; if (forbidden_name(c, a->asname, asname_node, 0)) return NULL; return a; } break; case dotted_name: if (NCH(n) == 1) { node *name_node = CHILD(n, 0); name = NEW_IDENTIFIER(name_node); if (!name) return NULL; if (store && forbidden_name(c, name, name_node, 0)) return NULL; return alias(name, NULL, c->c_arena); } else { /* Create a string of the form "a.b.c" */ int i; size_t len; char *s; PyObject *uni; len = 0; for (i = 0; i < NCH(n); i += 2) /* length of string plus one for the dot */ len += strlen(STR(CHILD(n, i))) + 1; len--; /* the last name doesn't have a dot */ str = PyBytes_FromStringAndSize(NULL, len); if (!str) return NULL; s = PyBytes_AS_STRING(str); if (!s) return NULL; for (i = 0; i < NCH(n); i += 2) { char *sch = STR(CHILD(n, i)); strcpy(s, STR(CHILD(n, i))); s += strlen(sch); *s++ = '.'; } --s; *s = '\0'; uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL); Py_DECREF(str); if (!uni) return NULL; str = uni; PyUnicode_InternInPlace(&str); if (PyArena_AddPyObject(c->c_arena, str) < 0) { Py_DECREF(str); return NULL; } return alias(str, NULL, c->c_arena); } break; case STAR: str = PyUnicode_InternFromString("*"); if (PyArena_AddPyObject(c->c_arena, str) < 0) { Py_DECREF(str); return NULL; } return alias(str, NULL, c->c_arena); default: PyErr_Format(PyExc_SystemError, "unexpected import name: %d", TYPE(n)); return NULL; } PyErr_SetString(PyExc_SystemError, "unhandled import name condition"); return NULL; } static stmt_ty ast_for_import_stmt(struct compiling *c, const node *n) { /* import_stmt: import_name | import_from import_name: 'import' dotted_as_names import_from: 'from' (('.' | '...')* dotted_name | ('.' | '...')+) 'import' ('*' | '(' import_as_names ')' | import_as_names) */ int lineno; int col_offset; int i; asdl_seq *aliases; REQ(n, import_stmt); lineno = LINENO(n); col_offset = n->n_col_offset; n = CHILD(n, 0); if (TYPE(n) == import_name) { n = CHILD(n, 1); REQ(n, dotted_as_names); aliases = _Ta3_asdl_seq_new((NCH(n) + 1) / 2, c->c_arena); if (!aliases) return NULL; for (i = 0; i < NCH(n); i += 2) { alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, i / 2, import_alias); } return Import(aliases, lineno, col_offset, c->c_arena); } else if (TYPE(n) == import_from) { int n_children; int idx, ndots = 0; alias_ty mod = NULL; identifier modname = NULL; /* Count the number of dots (for relative imports) and check for the optional module name */ for (idx = 1; idx < NCH(n); idx++) { if (TYPE(CHILD(n, idx)) == dotted_name) { mod = alias_for_import_name(c, CHILD(n, idx), 0); if (!mod) return NULL; idx++; break; } else if (TYPE(CHILD(n, idx)) == ELLIPSIS) { /* three consecutive dots are tokenized as one ELLIPSIS */ ndots += 3; continue; } else if (TYPE(CHILD(n, idx)) != DOT) { break; } ndots++; } idx++; /* skip over the 'import' keyword */ switch (TYPE(CHILD(n, idx))) { case STAR: /* from ... import * */ n = CHILD(n, idx); n_children = 1; break; case LPAR: /* from ... import (x, y, z) */ n = CHILD(n, idx + 1); n_children = NCH(n); break; case import_as_names: /* from ... import x, y, z */ n = CHILD(n, idx); n_children = NCH(n); if (n_children % 2 == 0) { ast_error(c, n, "trailing comma not allowed without" " surrounding parentheses"); return NULL; } break; default: ast_error(c, n, "Unexpected node-type in from-import"); return NULL; } aliases = _Ta3_asdl_seq_new((n_children + 1) / 2, c->c_arena); if (!aliases) return NULL; /* handle "from ... import *" special b/c there's no children */ if (TYPE(n) == STAR) { alias_ty import_alias = alias_for_import_name(c, n, 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, 0, import_alias); } else { for (i = 0; i < NCH(n); i += 2) { alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1); if (!import_alias) return NULL; asdl_seq_SET(aliases, i / 2, import_alias); } } if (mod != NULL) modname = mod->name; return ImportFrom(modname, aliases, ndots, lineno, col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unknown import statement: starts with command '%s'", STR(CHILD(n, 0))); return NULL; } static stmt_ty ast_for_global_stmt(struct compiling *c, const node *n) { /* global_stmt: 'global' NAME (',' NAME)* */ identifier name; asdl_seq *s; int i; REQ(n, global_stmt); s = _Ta3_asdl_seq_new(NCH(n) / 2, c->c_arena); if (!s) return NULL; for (i = 1; i < NCH(n); i += 2) { name = NEW_IDENTIFIER(CHILD(n, i)); if (!name) return NULL; asdl_seq_SET(s, i / 2, name); } return Global(s, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_nonlocal_stmt(struct compiling *c, const node *n) { /* nonlocal_stmt: 'nonlocal' NAME (',' NAME)* */ identifier name; asdl_seq *s; int i; REQ(n, nonlocal_stmt); s = _Ta3_asdl_seq_new(NCH(n) / 2, c->c_arena); if (!s) return NULL; for (i = 1; i < NCH(n); i += 2) { name = NEW_IDENTIFIER(CHILD(n, i)); if (!name) return NULL; asdl_seq_SET(s, i / 2, name); } return Nonlocal(s, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_assert_stmt(struct compiling *c, const node *n) { /* assert_stmt: 'assert' test [',' test] */ REQ(n, assert_stmt); if (NCH(n) == 2) { expr_ty expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; return Assert(expression, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(n) == 4) { expr_ty expr1, expr2; expr1 = ast_for_expr(c, CHILD(n, 1)); if (!expr1) return NULL; expr2 = ast_for_expr(c, CHILD(n, 3)); if (!expr2) return NULL; return Assert(expr1, expr2, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "improper number of parts to 'assert' statement: %d", NCH(n)); return NULL; } static asdl_seq * ast_for_suite(struct compiling *c, const node *n) { /* suite: simple_stmt | NEWLINE [TYPE_COMMENT NEWLINE] INDENT stmt+ DEDENT */ asdl_seq *seq; stmt_ty s; int i, total, num, end, pos = 0; node *ch; REQ(n, suite); total = num_stmts(n); seq = _Ta3_asdl_seq_new(total, c->c_arena); if (!seq) return NULL; if (TYPE(CHILD(n, 0)) == simple_stmt) { n = CHILD(n, 0); /* simple_stmt always ends with a NEWLINE, and may have a trailing SEMI */ end = NCH(n) - 1; if (TYPE(CHILD(n, end - 1)) == SEMI) end--; /* loop by 2 to skip semi-colons */ for (i = 0; i < end; i += 2) { ch = CHILD(n, i); s = ast_for_stmt(c, ch); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } } else { i = 2; if (TYPE(CHILD(n, 1)) == TYPE_COMMENT) i += 2; for (; i < (NCH(n) - 1); i++) { ch = CHILD(n, i); REQ(ch, stmt); num = num_stmts(ch); if (num == 1) { /* small_stmt or compound_stmt with only one child */ s = ast_for_stmt(c, ch); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } else { int j; ch = CHILD(ch, 0); REQ(ch, simple_stmt); for (j = 0; j < NCH(ch); j += 2) { /* statement terminates with a semi-colon ';' */ if (NCH(CHILD(ch, j)) == 0) { assert((j + 1) == NCH(ch)); break; } s = ast_for_stmt(c, CHILD(ch, j)); if (!s) return NULL; asdl_seq_SET(seq, pos++, s); } } } } assert(pos == seq->size); return seq; } static stmt_ty ast_for_if_stmt(struct compiling *c, const node *n) { /* if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */ char *s; REQ(n, if_stmt); if (NCH(n) == 4) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return If(expression, suite_seq, NULL, LINENO(n), n->n_col_offset, c->c_arena); } s = STR(CHILD(n, 4)); /* s[2], the third character in the string, will be 's' for el_s_e, or 'i' for el_i_f */ if (s[2] == 's') { expr_ty expression; asdl_seq *seq1, *seq2; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; seq1 = ast_for_suite(c, CHILD(n, 3)); if (!seq1) return NULL; seq2 = ast_for_suite(c, CHILD(n, 6)); if (!seq2) return NULL; return If(expression, seq1, seq2, LINENO(n), n->n_col_offset, c->c_arena); } else if (s[2] == 'i') { int i, n_elif, has_else = 0; expr_ty expression; asdl_seq *suite_seq; asdl_seq *orelse = NULL; n_elif = NCH(n) - 4; /* must reference the child n_elif+1 since 'else' token is third, not fourth, child from the end. */ if (TYPE(CHILD(n, (n_elif + 1))) == NAME && STR(CHILD(n, (n_elif + 1)))[2] == 's') { has_else = 1; n_elif -= 3; } n_elif /= 4; if (has_else) { asdl_seq *suite_seq2; orelse = _Ta3_asdl_seq_new(1, c->c_arena); if (!orelse) return NULL; expression = ast_for_expr(c, CHILD(n, NCH(n) - 6)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, NCH(n) - 4)); if (!suite_seq) return NULL; suite_seq2 = ast_for_suite(c, CHILD(n, NCH(n) - 1)); if (!suite_seq2) return NULL; asdl_seq_SET(orelse, 0, If(expression, suite_seq, suite_seq2, LINENO(CHILD(n, NCH(n) - 6)), CHILD(n, NCH(n) - 6)->n_col_offset, c->c_arena)); /* the just-created orelse handled the last elif */ n_elif--; } for (i = 0; i < n_elif; i++) { int off = 5 + (n_elif - i - 1) * 4; asdl_seq *newobj = _Ta3_asdl_seq_new(1, c->c_arena); if (!newobj) return NULL; expression = ast_for_expr(c, CHILD(n, off)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, off + 2)); if (!suite_seq) return NULL; asdl_seq_SET(newobj, 0, If(expression, suite_seq, orelse, LINENO(CHILD(n, off)), CHILD(n, off)->n_col_offset, c->c_arena)); orelse = newobj; } expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return If(expression, suite_seq, orelse, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "unexpected token in 'if' statement: %s", s); return NULL; } static stmt_ty ast_for_while_stmt(struct compiling *c, const node *n) { /* while_stmt: 'while' test ':' suite ['else' ':' suite] */ REQ(n, while_stmt); if (NCH(n) == 4) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 3)); if (!suite_seq) return NULL; return While(expression, suite_seq, NULL, LINENO(n), n->n_col_offset, c->c_arena); } else if (NCH(n) == 7) { expr_ty expression; asdl_seq *seq1, *seq2; expression = ast_for_expr(c, CHILD(n, 1)); if (!expression) return NULL; seq1 = ast_for_suite(c, CHILD(n, 3)); if (!seq1) return NULL; seq2 = ast_for_suite(c, CHILD(n, 6)); if (!seq2) return NULL; return While(expression, seq1, seq2, LINENO(n), n->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "wrong number of tokens for 'while' statement: %d", NCH(n)); return NULL; } static stmt_ty ast_for_for_stmt(struct compiling *c, const node *n, int is_async) { asdl_seq *_target, *seq = NULL, *suite_seq; expr_ty expression; expr_ty target, first; const node *node_target; int has_type_comment; string type_comment; if (is_async && c->c_feature_version < 5) { ast_error(c, n, "Async for loops are only supported in Python 3.5 and greater"); return NULL; } /* for_stmt: 'for' exprlist 'in' testlist ':' [TYPE_COMMENT] suite ['else' ':' suite] */ REQ(n, for_stmt); has_type_comment = TYPE(CHILD(n, 5)) == TYPE_COMMENT; if (NCH(n) == 9 + has_type_comment) { seq = ast_for_suite(c, CHILD(n, 8 + has_type_comment)); if (!seq) return NULL; } node_target = CHILD(n, 1); _target = ast_for_exprlist(c, node_target, Store); if (!_target) return NULL; /* Check the # of children rather than the length of _target, since for x, in ... has 1 element in _target, but still requires a Tuple. */ first = (expr_ty)asdl_seq_GET(_target, 0); if (NCH(node_target) == 1) target = first; else target = Tuple(_target, Store, first->lineno, first->col_offset, c->c_arena); expression = ast_for_testlist(c, CHILD(n, 3)); if (!expression) return NULL; suite_seq = ast_for_suite(c, CHILD(n, 5 + has_type_comment)); if (!suite_seq) return NULL; if (has_type_comment) type_comment = NEW_TYPE_COMMENT(CHILD(n, 5)); else type_comment = NULL; if (is_async) return AsyncFor(target, expression, suite_seq, seq, type_comment, LINENO(n), n->n_col_offset, c->c_arena); else return For(target, expression, suite_seq, seq, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } static excepthandler_ty ast_for_except_clause(struct compiling *c, const node *exc, node *body) { /* except_clause: 'except' [test ['as' test]] */ REQ(exc, except_clause); REQ(body, suite); if (NCH(exc) == 1) { asdl_seq *suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(NULL, NULL, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } else if (NCH(exc) == 2) { expr_ty expression; asdl_seq *suite_seq; expression = ast_for_expr(c, CHILD(exc, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(expression, NULL, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } else if (NCH(exc) == 4) { asdl_seq *suite_seq; expr_ty expression; identifier e = NEW_IDENTIFIER(CHILD(exc, 3)); if (!e) return NULL; if (forbidden_name(c, e, CHILD(exc, 3), 0)) return NULL; expression = ast_for_expr(c, CHILD(exc, 1)); if (!expression) return NULL; suite_seq = ast_for_suite(c, body); if (!suite_seq) return NULL; return ExceptHandler(expression, e, suite_seq, LINENO(exc), exc->n_col_offset, c->c_arena); } PyErr_Format(PyExc_SystemError, "wrong number of children for 'except' clause: %d", NCH(exc)); return NULL; } static stmt_ty ast_for_try_stmt(struct compiling *c, const node *n) { const int nch = NCH(n); int n_except = (nch - 3)/3; asdl_seq *body, *handlers = NULL, *orelse = NULL, *finally = NULL; REQ(n, try_stmt); body = ast_for_suite(c, CHILD(n, 2)); if (body == NULL) return NULL; if (TYPE(CHILD(n, nch - 3)) == NAME) { if (strcmp(STR(CHILD(n, nch - 3)), "finally") == 0) { if (nch >= 9 && TYPE(CHILD(n, nch - 6)) == NAME) { /* we can assume it's an "else", because nch >= 9 for try-else-finally and it would otherwise have a type of except_clause */ orelse = ast_for_suite(c, CHILD(n, nch - 4)); if (orelse == NULL) return NULL; n_except--; } finally = ast_for_suite(c, CHILD(n, nch - 1)); if (finally == NULL) return NULL; n_except--; } else { /* we can assume it's an "else", otherwise it would have a type of except_clause */ orelse = ast_for_suite(c, CHILD(n, nch - 1)); if (orelse == NULL) return NULL; n_except--; } } else if (TYPE(CHILD(n, nch - 3)) != except_clause) { ast_error(c, n, "malformed 'try' statement"); return NULL; } if (n_except > 0) { int i; /* process except statements to create a try ... except */ handlers = _Ta3_asdl_seq_new(n_except, c->c_arena); if (handlers == NULL) return NULL; for (i = 0; i < n_except; i++) { excepthandler_ty e = ast_for_except_clause(c, CHILD(n, 3 + i * 3), CHILD(n, 5 + i * 3)); if (!e) return NULL; asdl_seq_SET(handlers, i, e); } } assert(finally != NULL || asdl_seq_LEN(handlers)); return Try(body, handlers, orelse, finally, LINENO(n), n->n_col_offset, c->c_arena); } /* with_item: test ['as' expr] */ static withitem_ty ast_for_with_item(struct compiling *c, const node *n) { expr_ty context_expr, optional_vars = NULL; REQ(n, with_item); context_expr = ast_for_expr(c, CHILD(n, 0)); if (!context_expr) return NULL; if (NCH(n) == 3) { optional_vars = ast_for_expr(c, CHILD(n, 2)); if (!optional_vars) { return NULL; } if (!set_context(c, optional_vars, Store, n)) { return NULL; } } return withitem(context_expr, optional_vars, c->c_arena); } /* with_stmt: 'with' with_item (',' with_item)* ':' [TYPE_COMMENT] suite */ static stmt_ty ast_for_with_stmt(struct compiling *c, const node *n, int is_async) { int i, n_items, nch_minus_type, has_type_comment; asdl_seq *items, *body; string type_comment; if (is_async && c->c_feature_version < 5) { ast_error(c, n, "Async with statements are only supported in Python 3.5 and greater"); return NULL; } REQ(n, with_stmt); has_type_comment = TYPE(CHILD(n, NCH(n) - 2)) == TYPE_COMMENT; nch_minus_type = NCH(n) - has_type_comment; n_items = (nch_minus_type - 2) / 2; items = _Ta3_asdl_seq_new(n_items, c->c_arena); if (!items) return NULL; for (i = 1; i < nch_minus_type - 2; i += 2) { withitem_ty item = ast_for_with_item(c, CHILD(n, i)); if (!item) return NULL; asdl_seq_SET(items, (i - 1) / 2, item); } body = ast_for_suite(c, CHILD(n, NCH(n) - 1)); if (!body) return NULL; if (has_type_comment) type_comment = NEW_TYPE_COMMENT(CHILD(n, NCH(n) - 2)); else type_comment = NULL; if (is_async) return AsyncWith(items, body, type_comment, LINENO(n), n->n_col_offset, c->c_arena); else return With(items, body, type_comment, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) { /* classdef: 'class' NAME ['(' arglist ')'] ':' suite */ PyObject *classname; asdl_seq *s; expr_ty call; REQ(n, classdef); if (NCH(n) == 4) { /* class NAME ':' suite */ s = ast_for_suite(c, CHILD(n, 3)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; if (forbidden_name(c, classname, CHILD(n, 3), 0)) return NULL; return ClassDef(classname, NULL, NULL, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } if (TYPE(CHILD(n, 3)) == RPAR) { /* class NAME '(' ')' ':' suite */ s = ast_for_suite(c, CHILD(n,5)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; if (forbidden_name(c, classname, CHILD(n, 3), 0)) return NULL; return ClassDef(classname, NULL, NULL, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } /* class NAME '(' arglist ')' ':' suite */ /* build up a fake Call node so we can extract its pieces */ { PyObject *dummy_name; expr_ty dummy; dummy_name = NEW_IDENTIFIER(CHILD(n, 1)); if (!dummy_name) return NULL; dummy = Name(dummy_name, Load, LINENO(n), n->n_col_offset, c->c_arena); call = ast_for_call(c, CHILD(n, 3), dummy); if (!call) return NULL; } s = ast_for_suite(c, CHILD(n, 6)); if (!s) return NULL; classname = NEW_IDENTIFIER(CHILD(n, 1)); if (!classname) return NULL; if (forbidden_name(c, classname, CHILD(n, 1), 0)) return NULL; return ClassDef(classname, call->v.Call.args, call->v.Call.keywords, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty ast_for_stmt(struct compiling *c, const node *n) { if (TYPE(n) == stmt) { assert(NCH(n) == 1); n = CHILD(n, 0); } if (TYPE(n) == simple_stmt) { assert(num_stmts(n) == 1); n = CHILD(n, 0); } if (TYPE(n) == small_stmt) { n = CHILD(n, 0); /* small_stmt: expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt */ switch (TYPE(n)) { case expr_stmt: return ast_for_expr_stmt(c, n); case del_stmt: return ast_for_del_stmt(c, n); case pass_stmt: return Pass(LINENO(n), n->n_col_offset, c->c_arena); case flow_stmt: return ast_for_flow_stmt(c, n); case import_stmt: return ast_for_import_stmt(c, n); case global_stmt: return ast_for_global_stmt(c, n); case nonlocal_stmt: return ast_for_nonlocal_stmt(c, n); case assert_stmt: return ast_for_assert_stmt(c, n); default: PyErr_Format(PyExc_SystemError, "unhandled small_stmt: TYPE=%d NCH=%d\n", TYPE(n), NCH(n)); return NULL; } } else { /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef | decorated | async_stmt */ node *ch = CHILD(n, 0); REQ(n, compound_stmt); switch (TYPE(ch)) { case if_stmt: return ast_for_if_stmt(c, ch); case while_stmt: return ast_for_while_stmt(c, ch); case for_stmt: return ast_for_for_stmt(c, ch, 0); case try_stmt: return ast_for_try_stmt(c, ch); case with_stmt: return ast_for_with_stmt(c, ch, 0); case funcdef: return ast_for_funcdef(c, ch, NULL); case classdef: return ast_for_classdef(c, ch, NULL); case decorated: return ast_for_decorated(c, ch); case async_stmt: return ast_for_async_stmt(c, ch); default: PyErr_Format(PyExc_SystemError, "unhandled small_stmt: TYPE=%d NCH=%d\n", TYPE(n), NCH(n)); return NULL; } } } static PyObject * parsenumber_raw(struct compiling *c, const char *s) { const char *end; long x; double dx; Py_complex compl; int imflag; assert(s != NULL); errno = 0; end = s + strlen(s) - 1; imflag = *end == 'j' || *end == 'J'; if (s[0] == '0') { x = (long) PyOS_strtoul(s, (char **)&end, 0); if (x < 0 && errno == 0) { return PyLong_FromString(s, (char **)0, 0); } } else x = PyOS_strtol(s, (char **)&end, 0); if (*end == '\0') { if (errno != 0) return PyLong_FromString(s, (char **)0, 0); return PyLong_FromLong(x); } /* XXX Huge floats may silently fail */ if (imflag) { compl.real = 0.; compl.imag = PyOS_string_to_double(s, (char **)&end, NULL); if (compl.imag == -1.0 && PyErr_Occurred()) return NULL; return PyComplex_FromCComplex(compl); } else { dx = PyOS_string_to_double(s, NULL, NULL); if (dx == -1.0 && PyErr_Occurred()) return NULL; return PyFloat_FromDouble(dx); } } static PyObject * parsenumber(struct compiling *c, const char *s) { char *dup, *end; PyObject *res = NULL; assert(s != NULL); if (strchr(s, '_') == NULL) { return parsenumber_raw(c, s); } /* Create a duplicate without underscores. */ dup = PyMem_Malloc(strlen(s) + 1); end = dup; for (; *s; s++) { if (*s != '_') { *end++ = *s; } } *end = '\0'; res = parsenumber_raw(c, dup); PyMem_Free(dup); return res; } static PyObject * decode_utf8(struct compiling *c, const char **sPtr, const char *end) { const char *s, *t; t = s = *sPtr; /* while (s < end && *s != '\\') s++; */ /* inefficient for u".." */ while (s < end && (*s & 0x80)) s++; *sPtr = s; return PyUnicode_DecodeUTF8(t, s - t, NULL); } static PyObject * decode_unicode_with_escapes(struct compiling *c, const node *n, const char *s, size_t len) { PyObject *u; char *buf; char *p; const char *end; /* check for integer overflow */ if (len > SIZE_MAX / 6) return NULL; /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5 "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */ u = PyBytes_FromStringAndSize((char *)NULL, len * 6); if (u == NULL) return NULL; p = buf = PyBytes_AsString(u); end = s + len; while (s < end) { if (*s == '\\') { *p++ = *s++; if (*s & 0x80) { strcpy(p, "u005c"); p += 5; } } if (*s & 0x80) { /* XXX inefficient */ PyObject *w; int kind; void *data; Py_ssize_t len, i; w = decode_utf8(c, &s, end); if (w == NULL) { Py_DECREF(u); return NULL; } kind = PyUnicode_KIND(w); data = PyUnicode_DATA(w); len = PyUnicode_GET_LENGTH(w); for (i = 0; i < len; i++) { Py_UCS4 chr = PyUnicode_READ(kind, data, i); sprintf(p, "\\U%08x", chr); p += 10; } /* Should be impossible to overflow */ assert(p - buf <= Py_SIZE(u)); Py_DECREF(w); } else { *p++ = *s++; } } len = p - buf; s = buf; return PyUnicode_DecodeUnicodeEscape(s, len, NULL); } static PyObject * decode_bytes_with_escapes(struct compiling *c, const node *n, const char *s, size_t len) { return PyBytes_DecodeEscape(s, len, NULL, 0, NULL); } /* Compile this expression in to an expr_ty. Add parens around the expression, in order to allow leading spaces in the expression. */ static expr_ty fstring_compile_expr(const char *expr_start, const char *expr_end, struct compiling *c, const node *n) { int all_whitespace = 1; int kind; void *data; PyCompilerFlags cf; mod_ty mod; char *str; PyObject *o, *fstring_name; Py_ssize_t len; Py_ssize_t i; assert(expr_end >= expr_start); assert(*(expr_start-1) == '{'); assert(*expr_end == '}' || *expr_end == '!' || *expr_end == ':'); /* We know there are no escapes here, because backslashes are not allowed, and we know it's utf-8 encoded (per PEP 263). But, in order to check that each char is not whitespace, we need to decode it to unicode. Which is unfortunate, but such is life. */ /* If the substring is all whitespace, it's an error. We need to catch this here, and not when we call PyParser_ASTFromString, because turning the expression '' in to '()' would go from being invalid to valid. */ /* Note that this code says an empty string is all whitespace. That's important. There's a test for it: f'{}'. */ o = PyUnicode_DecodeUTF8(expr_start, expr_end-expr_start, NULL); if (o == NULL) return NULL; len = PyUnicode_GET_LENGTH(o); kind = PyUnicode_KIND(o); data = PyUnicode_DATA(o); for (i = 0; i < len; i++) { if (!Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, i))) { all_whitespace = 0; break; } } Py_DECREF(o); if (all_whitespace) { ast_error(c, n, "f-string: empty expression not allowed"); return NULL; } /* Reuse len to be the length of the utf-8 input string. */ len = expr_end - expr_start; /* Allocate 3 extra bytes: open paren, close paren, null byte. */ str = PyMem_RawMalloc(len + 3); if (str == NULL) return NULL; str[0] = '('; memcpy(str+1, expr_start, len); str[len+1] = ')'; str[len+2] = 0; cf.cf_flags = PyCF_ONLY_AST; fstring_name = PyUnicode_FromString(""); mod = string_object_to_c_ast(str, fstring_name, Py_eval_input, &cf, c->c_feature_version, c->c_arena); Py_DECREF(fstring_name); PyMem_RawFree(str); if (!mod) return NULL; return mod->v.Expression.body; } /* Return -1 on error. Return 0 if we reached the end of the literal. Return 1 if we haven't reached the end of the literal, but we want the caller to process the literal up to this point. Used for doubled braces. */ static int fstring_find_literal(const char **str, const char *end, int raw, PyObject **literal, int recurse_lvl, struct compiling *c, const node *n) { /* Get any literal string. It ends when we hit an un-doubled left brace (which isn't part of a unicode name escape such as "\N{EULER CONSTANT}"), or the end of the string. */ const char *literal_start = *str; const char *literal_end; int in_named_escape = 0; int result = 0; assert(*literal == NULL); for (; *str < end; (*str)++) { char ch = **str; if (!in_named_escape && ch == '{' && (*str)-literal_start >= 2 && *(*str-2) == '\\' && *(*str-1) == 'N') { in_named_escape = 1; } else if (in_named_escape && ch == '}') { in_named_escape = 0; } else if (ch == '{' || ch == '}') { /* Check for doubled braces, but only at the top level. If we checked at every level, then f'{0:{3}}' would fail with the two closing braces. */ if (recurse_lvl == 0) { if (*str+1 < end && *(*str+1) == ch) { /* We're going to tell the caller that the literal ends here, but that they should continue scanning. But also skip over the second brace when we resume scanning. */ literal_end = *str+1; *str += 2; result = 1; goto done; } /* Where a single '{' is the start of a new expression, a single '}' is not allowed. */ if (ch == '}') { ast_error(c, n, "f-string: single '}' is not allowed"); return -1; } } /* We're either at a '{', which means we're starting another expression; or a '}', which means we're at the end of this f-string (for a nested format_spec). */ break; } } literal_end = *str; assert(*str <= end); assert(*str == end || **str == '{' || **str == '}'); done: if (literal_start != literal_end) { if (raw) *literal = PyUnicode_DecodeUTF8Stateful(literal_start, literal_end-literal_start, NULL, NULL); else *literal = decode_unicode_with_escapes(c, n, literal_start, literal_end-literal_start); if (!*literal) return -1; } return result; } /* Forward declaration because parsing is recursive. */ static expr_ty fstring_parse(const char **str, const char *end, int raw, int recurse_lvl, struct compiling *c, const node *n); /* Parse the f-string at *str, ending at end. We know *str starts an expression (so it must be a '{'). Returns the FormattedValue node, which includes the expression, conversion character, and format_spec expression. Note that I don't do a perfect job here: I don't make sure that a closing brace doesn't match an opening paren, for example. It doesn't need to error on all invalid expressions, just correctly find the end of all valid ones. Any errors inside the expression will be caught when we parse it later. */ static int fstring_find_expr(const char **str, const char *end, int raw, int recurse_lvl, expr_ty *expression, struct compiling *c, const node *n) { /* Return -1 on error, else 0. */ const char *expr_start; const char *expr_end; expr_ty simple_expression; expr_ty format_spec = NULL; /* Optional format specifier. */ int conversion = -1; /* The conversion char. -1 if not specified. */ /* 0 if we're not in a string, else the quote char we're trying to match (single or double quote). */ char quote_char = 0; /* If we're inside a string, 1=normal, 3=triple-quoted. */ int string_type = 0; /* Keep track of nesting level for braces/parens/brackets in expressions. */ Py_ssize_t nested_depth = 0; /* Can only nest one level deep. */ if (recurse_lvl >= 2) { ast_error(c, n, "f-string: expressions nested too deeply"); return -1; } /* The first char must be a left brace, or we wouldn't have gotten here. Skip over it. */ assert(**str == '{'); *str += 1; expr_start = *str; for (; *str < end; (*str)++) { char ch; /* Loop invariants. */ assert(nested_depth >= 0); assert(*str >= expr_start && *str < end); if (quote_char) assert(string_type == 1 || string_type == 3); else assert(string_type == 0); ch = **str; /* Nowhere inside an expression is a backslash allowed. */ if (ch == '\\') { /* Error: can't include a backslash character, inside parens or strings or not. */ ast_error(c, n, "f-string expression part " "cannot include a backslash"); return -1; } if (quote_char) { /* We're inside a string. See if we're at the end. */ /* This code needs to implement the same non-error logic as tok_get from tokenizer.c, at the letter_quote label. To actually share that code would be a nightmare. But, it's unlikely to change and is small, so duplicate it here. Note we don't need to catch all of the errors, since they'll be caught when parsing the expression. We just need to match the non-error cases. Thus we can ignore \n in single-quoted strings, for example. Or non-terminated strings. */ if (ch == quote_char) { /* Does this match the string_type (single or triple quoted)? */ if (string_type == 3) { if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) { /* We're at the end of a triple quoted string. */ *str += 2; string_type = 0; quote_char = 0; continue; } } else { /* We're at the end of a normal string. */ quote_char = 0; string_type = 0; continue; } } } else if (ch == '\'' || ch == '"') { /* Is this a triple quoted string? */ if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) { string_type = 3; *str += 2; } else { /* Start of a normal string. */ string_type = 1; } /* Start looking for the end of the string. */ quote_char = ch; } else if (ch == '[' || ch == '{' || ch == '(') { nested_depth++; } else if (nested_depth != 0 && (ch == ']' || ch == '}' || ch == ')')) { nested_depth--; } else if (ch == '#') { /* Error: can't include a comment character, inside parens or not. */ ast_error(c, n, "f-string expression part cannot include '#'"); return -1; } else if (nested_depth == 0 && (ch == '!' || ch == ':' || ch == '}')) { /* First, test for the special case of "!=". Since '=' is not an allowed conversion character, nothing is lost in this test. */ if (ch == '!' && *str+1 < end && *(*str+1) == '=') { /* This isn't a conversion character, just continue. */ continue; } /* Normal way out of this loop. */ break; } else { /* Just consume this char and loop around. */ } } expr_end = *str; /* If we leave this loop in a string or with mismatched parens, we don't care. We'll get a syntax error when compiling the expression. But, we can produce a better error message, so let's just do that.*/ if (quote_char) { ast_error(c, n, "f-string: unterminated string"); return -1; } if (nested_depth) { ast_error(c, n, "f-string: mismatched '(', '{', or '['"); return -1; } if (*str >= end) goto unexpected_end_of_string; /* Compile the expression as soon as possible, so we show errors related to the expression before errors related to the conversion or format_spec. */ simple_expression = fstring_compile_expr(expr_start, expr_end, c, n); if (!simple_expression) return -1; /* Check for a conversion char, if present. */ if (**str == '!') { *str += 1; if (*str >= end) goto unexpected_end_of_string; conversion = **str; *str += 1; /* Validate the conversion. */ if (!(conversion == 's' || conversion == 'r' || conversion == 'a')) { ast_error(c, n, "f-string: invalid conversion character: " "expected 's', 'r', or 'a'"); return -1; } } /* Check for the format spec, if present. */ if (*str >= end) goto unexpected_end_of_string; if (**str == ':') { *str += 1; if (*str >= end) goto unexpected_end_of_string; /* Parse the format spec. */ format_spec = fstring_parse(str, end, raw, recurse_lvl+1, c, n); if (!format_spec) return -1; } if (*str >= end || **str != '}') goto unexpected_end_of_string; /* We're at a right brace. Consume it. */ assert(*str < end); assert(**str == '}'); *str += 1; /* And now create the FormattedValue node that represents this entire expression with the conversion and format spec. */ *expression = FormattedValue(simple_expression, conversion, format_spec, LINENO(n), n->n_col_offset, c->c_arena); if (!*expression) return -1; return 0; unexpected_end_of_string: ast_error(c, n, "f-string: expecting '}'"); return -1; } /* Return -1 on error. Return 0 if we have a literal (possible zero length) and an expression (zero length if at the end of the string. Return 1 if we have a literal, but no expression, and we want the caller to call us again. This is used to deal with doubled braces. When called multiple times on the string 'a{{b{0}c', this function will return: 1. the literal 'a{' with no expression, and a return value of 1. Despite the fact that there's no expression, the return value of 1 means we're not finished yet. 2. the literal 'b' and the expression '0', with a return value of 0. The fact that there's an expression means we're not finished. 3. literal 'c' with no expression and a return value of 0. The combination of the return value of 0 with no expression means we're finished. */ static int fstring_find_literal_and_expr(const char **str, const char *end, int raw, int recurse_lvl, PyObject **literal, expr_ty *expression, struct compiling *c, const node *n) { int result; assert(*literal == NULL && *expression == NULL); /* Get any literal string. */ result = fstring_find_literal(str, end, raw, literal, recurse_lvl, c, n); if (result < 0) goto error; assert(result == 0 || result == 1); if (result == 1) /* We have a literal, but don't look at the expression. */ return 1; if (*str >= end || **str == '}') /* We're at the end of the string or the end of a nested f-string: no expression. The top-level error case where we expect to be at the end of the string but we're at a '}' is handled later. */ return 0; /* We must now be the start of an expression, on a '{'. */ assert(**str == '{'); if (fstring_find_expr(str, end, raw, recurse_lvl, expression, c, n) < 0) goto error; return 0; error: Py_CLEAR(*literal); return -1; } #define EXPRLIST_N_CACHED 64 typedef struct { /* Incrementally build an array of expr_ty, so be used in an asdl_seq. Cache some small but reasonably sized number of expr_ty's, and then after that start dynamically allocating, doubling the number allocated each time. Note that the f-string f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one Str for the literal 'a'. So you add expr_ty's about twice as fast as you add exressions in an f-string. */ Py_ssize_t allocated; /* Number we've allocated. */ Py_ssize_t size; /* Number we've used. */ expr_ty *p; /* Pointer to the memory we're actually using. Will point to 'data' until we start dynamically allocating. */ expr_ty data[EXPRLIST_N_CACHED]; } ExprList; #ifdef NDEBUG #define ExprList_check_invariants(l) #else static void ExprList_check_invariants(ExprList *l) { /* Check our invariants. Make sure this object is "live", and hasn't been deallocated. */ assert(l->size >= 0); assert(l->p != NULL); if (l->size <= EXPRLIST_N_CACHED) assert(l->data == l->p); } #endif static void ExprList_Init(ExprList *l) { l->allocated = EXPRLIST_N_CACHED; l->size = 0; /* Until we start allocating dynamically, p points to data. */ l->p = l->data; ExprList_check_invariants(l); } static int ExprList_Append(ExprList *l, expr_ty exp) { ExprList_check_invariants(l); if (l->size >= l->allocated) { /* We need to alloc (or realloc) the memory. */ Py_ssize_t new_size = l->allocated * 2; /* See if we've ever allocated anything dynamically. */ if (l->p == l->data) { Py_ssize_t i; /* We're still using the cached data. Switch to alloc-ing. */ l->p = PyMem_RawMalloc(sizeof(expr_ty) * new_size); if (!l->p) return -1; /* Copy the cached data into the new buffer. */ for (i = 0; i < l->size; i++) l->p[i] = l->data[i]; } else { /* Just realloc. */ expr_ty *tmp = PyMem_RawRealloc(l->p, sizeof(expr_ty) * new_size); if (!tmp) { PyMem_RawFree(l->p); l->p = NULL; return -1; } l->p = tmp; } l->allocated = new_size; assert(l->allocated == 2 * l->size); } l->p[l->size++] = exp; ExprList_check_invariants(l); return 0; } static void ExprList_Dealloc(ExprList *l) { ExprList_check_invariants(l); /* If there's been an error, or we've never dynamically allocated, do nothing. */ if (!l->p || l->p == l->data) { /* Do nothing. */ } else { /* We have dynamically allocated. Free the memory. */ PyMem_RawFree(l->p); } l->p = NULL; l->size = -1; } static asdl_seq * ExprList_Finish(ExprList *l, PyArena *arena) { asdl_seq *seq; ExprList_check_invariants(l); /* Allocate the asdl_seq and copy the expressions in to it. */ seq = _Ta3_asdl_seq_new(l->size, arena); if (seq) { Py_ssize_t i; for (i = 0; i < l->size; i++) asdl_seq_SET(seq, i, l->p[i]); } ExprList_Dealloc(l); return seq; } /* The FstringParser is designed to add a mix of strings and f-strings, and concat them together as needed. Ultimately, it generates an expr_ty. */ typedef struct { PyObject *last_str; ExprList expr_list; } FstringParser; #ifdef NDEBUG #define FstringParser_check_invariants(state) #else static void FstringParser_check_invariants(FstringParser *state) { if (state->last_str) assert(PyUnicode_CheckExact(state->last_str)); ExprList_check_invariants(&state->expr_list); } #endif static void FstringParser_Init(FstringParser *state) { state->last_str = NULL; ExprList_Init(&state->expr_list); FstringParser_check_invariants(state); } static void FstringParser_Dealloc(FstringParser *state) { FstringParser_check_invariants(state); Py_XDECREF(state->last_str); ExprList_Dealloc(&state->expr_list); } /* Make a Str node, but decref the PyUnicode object being added. */ static expr_ty make_str_node_and_del(PyObject **str, struct compiling *c, const node* n) { PyObject *s = *str; *str = NULL; assert(PyUnicode_CheckExact(s)); if (PyArena_AddPyObject(c->c_arena, s) < 0) { Py_DECREF(s); return NULL; } return Str(s, LINENO(n), n->n_col_offset, c->c_arena); } /* Add a non-f-string (that is, a regular literal string). str is decref'd. */ static int FstringParser_ConcatAndDel(FstringParser *state, PyObject *str) { FstringParser_check_invariants(state); assert(PyUnicode_CheckExact(str)); if (PyUnicode_GET_LENGTH(str) == 0) { Py_DECREF(str); return 0; } if (!state->last_str) { /* We didn't have a string before, so just remember this one. */ state->last_str = str; } else { /* Concatenate this with the previous string. */ PyUnicode_AppendAndDel(&state->last_str, str); if (!state->last_str) return -1; } FstringParser_check_invariants(state); return 0; } /* Parse an f-string. The f-string is in *str to end, with no 'f' or quotes. */ static int FstringParser_ConcatFstring(FstringParser *state, const char **str, const char *end, int raw, int recurse_lvl, struct compiling *c, const node *n) { FstringParser_check_invariants(state); /* Parse the f-string. */ while (1) { PyObject *literal = NULL; expr_ty expression = NULL; /* If there's a zero length literal in front of the expression, literal will be NULL. If we're at the end of the f-string, expression will be NULL (unless result == 1, see below). */ int result = fstring_find_literal_and_expr(str, end, raw, recurse_lvl, &literal, &expression, c, n); if (result < 0) return -1; /* Add the literal, if any. */ if (!literal) { /* Do nothing. Just leave last_str alone (and possibly NULL). */ } else if (!state->last_str) { state->last_str = literal; literal = NULL; } else { /* We have a literal, concatenate it. */ assert(PyUnicode_GET_LENGTH(literal) != 0); if (FstringParser_ConcatAndDel(state, literal) < 0) return -1; literal = NULL; } assert(!state->last_str || PyUnicode_GET_LENGTH(state->last_str) != 0); /* We've dealt with the literal now. It can't be leaked on further errors. */ assert(literal == NULL); /* See if we should just loop around to get the next literal and expression, while ignoring the expression this time. This is used for un-doubling braces, as an optimization. */ if (result == 1) continue; if (!expression) /* We're done with this f-string. */ break; /* We know we have an expression. Convert any existing string to a Str node. */ if (!state->last_str) { /* Do nothing. No previous literal. */ } else { /* Convert the existing last_str literal to a Str node. */ expr_ty str = make_str_node_and_del(&state->last_str, c, n); if (!str || ExprList_Append(&state->expr_list, str) < 0) return -1; } if (ExprList_Append(&state->expr_list, expression) < 0) return -1; } /* If recurse_lvl is zero, then we must be at the end of the string. Otherwise, we must be at a right brace. */ if (recurse_lvl == 0 && *str < end-1) { ast_error(c, n, "f-string: unexpected end of string"); return -1; } if (recurse_lvl != 0 && **str != '}') { ast_error(c, n, "f-string: expecting '}'"); return -1; } FstringParser_check_invariants(state); return 0; } /* Convert the partial state reflected in last_str and expr_list to an expr_ty. The expr_ty can be a Str, or a JoinedStr. */ static expr_ty FstringParser_Finish(FstringParser *state, struct compiling *c, const node *n) { asdl_seq *seq; FstringParser_check_invariants(state); /* If we're just a constant string with no expressions, return that. */ if(state->expr_list.size == 0) { if (!state->last_str) { /* Create a zero length string. */ state->last_str = PyUnicode_FromStringAndSize(NULL, 0); if (!state->last_str) goto error; } return make_str_node_and_del(&state->last_str, c, n); } /* Create a Str node out of last_str, if needed. It will be the last node in our expression list. */ if (state->last_str) { expr_ty str = make_str_node_and_del(&state->last_str, c, n); if (!str || ExprList_Append(&state->expr_list, str) < 0) goto error; } /* This has already been freed. */ assert(state->last_str == NULL); seq = ExprList_Finish(&state->expr_list, c->c_arena); if (!seq) goto error; /* If there's only one expression, return it. Otherwise, we need to join them together. */ if (seq->size == 1) return seq->elements[0]; return JoinedStr(seq, LINENO(n), n->n_col_offset, c->c_arena); error: FstringParser_Dealloc(state); return NULL; } /* Given an f-string (with no 'f' or quotes) that's in *str and ends at end, parse it into an expr_ty. Return NULL on error. Adjust str to point past the parsed portion. */ static expr_ty fstring_parse(const char **str, const char *end, int raw, int recurse_lvl, struct compiling *c, const node *n) { FstringParser state; FstringParser_Init(&state); if (FstringParser_ConcatFstring(&state, str, end, raw, recurse_lvl, c, n) < 0) { FstringParser_Dealloc(&state); return NULL; } return FstringParser_Finish(&state, c, n); } /* n is a Python string literal, including the bracketing quote characters, and r, b, u, &/or f prefixes (if any), and embedded escape sequences (if any). parsestr parses it, and sets *result to decoded Python string object. If the string is an f-string, set *fstr and *fstrlen to the unparsed string object. Return 0 if no errors occurred. */ static int parsestr(struct compiling *c, const node *n, int *bytesmode, int *rawmode, PyObject **result, const char **fstr, Py_ssize_t *fstrlen) { size_t len; const char *s = STR(n); int quote = Py_CHARMASK(*s); int fmode = 0; *bytesmode = 0; *rawmode = 0; *result = NULL; *fstr = NULL; if (Py_ISALPHA(quote)) { while (!*bytesmode || !*rawmode) { if (quote == 'b' || quote == 'B') { quote = *++s; *bytesmode = 1; } else if (quote == 'u' || quote == 'U') { quote = *++s; } else if (quote == 'r' || quote == 'R') { quote = *++s; *rawmode = 1; } else if (quote == 'f' || quote == 'F') { quote = *++s; fmode = 1; } else { break; } } } /* fstrings are only allowed in Python 3.6 and greater */ if (fmode && c->c_feature_version < 6) { ast_error(c, n, "Format strings are only supported in Python 3.6 and greater"); return -1; } if (fmode && *bytesmode) { PyErr_BadInternalCall(); return -1; } if (quote != '\'' && quote != '\"') { PyErr_BadInternalCall(); return -1; } /* Skip the leading quote char. */ s++; len = strlen(s); if (len > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "string to parse is too long"); return -1; } if (s[--len] != quote) { /* Last quote char must match the first. */ PyErr_BadInternalCall(); return -1; } if (len >= 4 && s[0] == quote && s[1] == quote) { /* A triple quoted string. We've already skipped one quote at the start and one at the end of the string. Now skip the two at the start. */ s += 2; len -= 2; /* And check that the last two match. */ if (s[--len] != quote || s[--len] != quote) { PyErr_BadInternalCall(); return -1; } } if (fmode) { /* Just return the bytes. The caller will parse the resulting string. */ *fstr = s; *fstrlen = len; return 0; } /* Not an f-string. */ /* Avoid invoking escape decoding routines if possible. */ *rawmode = *rawmode || strchr(s, '\\') == NULL; if (*bytesmode) { /* Disallow non-ASCII characters. */ const char *ch; for (ch = s; *ch; ch++) { if (Py_CHARMASK(*ch) >= 0x80) { ast_error(c, n, "bytes can only contain ASCII " "literal characters."); return -1; } } if (*rawmode) *result = PyBytes_FromStringAndSize(s, len); else *result = decode_bytes_with_escapes(c, n, s, len); } else { if (*rawmode) *result = PyUnicode_DecodeUTF8Stateful(s, len, NULL, NULL); else *result = decode_unicode_with_escapes(c, n, s, len); } return *result == NULL ? -1 : 0; } /* Accepts a STRING+ atom, and produces an expr_ty node. Run through each STRING atom, and process it as needed. For bytes, just concatenate them together, and the result will be a Bytes node. For normal strings and f-strings, concatenate them together. The result will be a Str node if there were no f-strings; a FormattedValue node if there's just an f-string (with no leading or trailing literals), or a JoinedStr node if there are multiple f-strings or any literals involved. */ static expr_ty parsestrplus(struct compiling *c, const node *n) { int bytesmode = 0; PyObject *bytes_str = NULL; int i; FstringParser state; FstringParser_Init(&state); for (i = 0; i < NCH(n); i++) { int this_bytesmode; int this_rawmode; PyObject *s; const char *fstr; Py_ssize_t fstrlen = -1; /* Silence a compiler warning. */ REQ(CHILD(n, i), STRING); if (parsestr(c, CHILD(n, i), &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen) != 0) goto error; /* Check that we're not mixing bytes with unicode. */ if (i != 0 && bytesmode != this_bytesmode) { ast_error(c, n, "cannot mix bytes and nonbytes literals"); /* s is NULL if the current string part is an f-string. */ Py_XDECREF(s); goto error; } bytesmode = this_bytesmode; if (fstr != NULL) { int result; assert(s == NULL && !bytesmode); /* This is an f-string. Parse and concatenate it. */ result = FstringParser_ConcatFstring(&state, &fstr, fstr+fstrlen, this_rawmode, 0, c, n); if (result < 0) goto error; } else { /* A string or byte string. */ assert(s != NULL && fstr == NULL); assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s)); if (bytesmode) { /* For bytes, concat as we go. */ if (i == 0) { /* First time, just remember this value. */ bytes_str = s; } else { PyBytes_ConcatAndDel(&bytes_str, s); if (!bytes_str) goto error; } } else { /* This is a regular string. Concatenate it. */ if (FstringParser_ConcatAndDel(&state, s) < 0) goto error; } } } if (bytesmode) { /* Just return the bytes object and we're done. */ if (PyArena_AddPyObject(c->c_arena, bytes_str) < 0) goto error; return Bytes(bytes_str, LINENO(n), n->n_col_offset, c->c_arena); } /* We're not a bytes string, bytes_str should never have been set. */ assert(bytes_str == NULL); return FstringParser_Finish(&state, c, n); error: Py_XDECREF(bytes_str); FstringParser_Dealloc(&state); return NULL; } typed-ast-1.1.0/ast3/Python/graminit.c0000644€Tøžæ€2›s®0000013511613050212017021027 0ustar ddfisher00000000000000/* Generated by Parser/pgen */ #include "pgenheaders.h" #include "grammar.h" extern grammar _Ta3Parser_Grammar; static arc arcs_0_0[3] = { {2, 1}, {3, 1}, {4, 2}, }; static arc arcs_0_1[1] = { {0, 1}, }; static arc arcs_0_2[1] = { {2, 1}, }; static state states_0[3] = { {3, arcs_0_0}, {1, arcs_0_1}, {1, arcs_0_2}, }; static arc arcs_1_0[3] = { {2, 0}, {6, 0}, {7, 1}, }; static arc arcs_1_1[1] = { {0, 1}, }; static state states_1[2] = { {3, arcs_1_0}, {1, arcs_1_1}, }; static arc arcs_2_0[1] = { {9, 1}, }; static arc arcs_2_1[2] = { {2, 1}, {7, 2}, }; static arc arcs_2_2[1] = { {0, 2}, }; static state states_2[3] = { {1, arcs_2_0}, {2, arcs_2_1}, {1, arcs_2_2}, }; static arc arcs_3_0[1] = { {11, 1}, }; static arc arcs_3_1[1] = { {12, 2}, }; static arc arcs_3_2[2] = { {13, 3}, {2, 4}, }; static arc arcs_3_3[2] = { {14, 5}, {15, 6}, }; static arc arcs_3_4[1] = { {0, 4}, }; static arc arcs_3_5[1] = { {15, 6}, }; static arc arcs_3_6[1] = { {2, 4}, }; static state states_3[7] = { {1, arcs_3_0}, {1, arcs_3_1}, {2, arcs_3_2}, {2, arcs_3_3}, {1, arcs_3_4}, {1, arcs_3_5}, {1, arcs_3_6}, }; static arc arcs_4_0[1] = { {10, 1}, }; static arc arcs_4_1[2] = { {10, 1}, {0, 1}, }; static state states_4[2] = { {1, arcs_4_0}, {2, arcs_4_1}, }; static arc arcs_5_0[1] = { {16, 1}, }; static arc arcs_5_1[3] = { {18, 2}, {19, 2}, {20, 2}, }; static arc arcs_5_2[1] = { {0, 2}, }; static state states_5[3] = { {1, arcs_5_0}, {3, arcs_5_1}, {1, arcs_5_2}, }; static arc arcs_6_0[1] = { {21, 1}, }; static arc arcs_6_1[1] = { {19, 2}, }; static arc arcs_6_2[1] = { {0, 2}, }; static state states_6[3] = { {1, arcs_6_0}, {1, arcs_6_1}, {1, arcs_6_2}, }; static arc arcs_7_0[1] = { {22, 1}, }; static arc arcs_7_1[1] = { {23, 2}, }; static arc arcs_7_2[1] = { {24, 3}, }; static arc arcs_7_3[2] = { {25, 4}, {27, 5}, }; static arc arcs_7_4[1] = { {26, 6}, }; static arc arcs_7_5[2] = { {28, 7}, {29, 8}, }; static arc arcs_7_6[1] = { {27, 5}, }; static arc arcs_7_7[1] = { {29, 8}, }; static arc arcs_7_8[1] = { {0, 8}, }; static state states_7[9] = { {1, arcs_7_0}, {1, arcs_7_1}, {1, arcs_7_2}, {2, arcs_7_3}, {1, arcs_7_4}, {2, arcs_7_5}, {1, arcs_7_6}, {1, arcs_7_7}, {1, arcs_7_8}, }; static arc arcs_8_0[1] = { {13, 1}, }; static arc arcs_8_1[2] = { {30, 2}, {15, 3}, }; static arc arcs_8_2[1] = { {15, 3}, }; static arc arcs_8_3[1] = { {0, 3}, }; static state states_8[4] = { {1, arcs_8_0}, {2, arcs_8_1}, {1, arcs_8_2}, {1, arcs_8_3}, }; static arc arcs_9_0[3] = { {31, 1}, {34, 2}, {35, 3}, }; static arc arcs_9_1[4] = { {32, 4}, {33, 5}, {28, 6}, {0, 1}, }; static arc arcs_9_2[4] = { {31, 7}, {33, 8}, {28, 6}, {0, 2}, }; static arc arcs_9_3[1] = { {31, 9}, }; static arc arcs_9_4[1] = { {26, 10}, }; static arc arcs_9_5[5] = { {28, 11}, {31, 12}, {34, 13}, {35, 3}, {0, 5}, }; static arc arcs_9_6[1] = { {0, 6}, }; static arc arcs_9_7[3] = { {33, 8}, {28, 6}, {0, 7}, }; static arc arcs_9_8[4] = { {28, 14}, {31, 15}, {35, 3}, {0, 8}, }; static arc arcs_9_9[3] = { {33, 16}, {28, 6}, {0, 9}, }; static arc arcs_9_10[3] = { {33, 5}, {28, 6}, {0, 10}, }; static arc arcs_9_11[4] = { {31, 12}, {34, 13}, {35, 3}, {0, 11}, }; static arc arcs_9_12[4] = { {33, 5}, {32, 4}, {28, 6}, {0, 12}, }; static arc arcs_9_13[4] = { {31, 17}, {33, 18}, {28, 6}, {0, 13}, }; static arc arcs_9_14[3] = { {31, 15}, {35, 3}, {0, 14}, }; static arc arcs_9_15[4] = { {33, 8}, {32, 19}, {28, 6}, {0, 15}, }; static arc arcs_9_16[2] = { {28, 6}, {0, 16}, }; static arc arcs_9_17[3] = { {33, 18}, {28, 6}, {0, 17}, }; static arc arcs_9_18[4] = { {28, 20}, {31, 21}, {35, 3}, {0, 18}, }; static arc arcs_9_19[1] = { {26, 7}, }; static arc arcs_9_20[3] = { {31, 21}, {35, 3}, {0, 20}, }; static arc arcs_9_21[4] = { {33, 18}, {32, 22}, {28, 6}, {0, 21}, }; static arc arcs_9_22[1] = { {26, 17}, }; static state states_9[23] = { {3, arcs_9_0}, {4, arcs_9_1}, {4, arcs_9_2}, {1, arcs_9_3}, {1, arcs_9_4}, {5, arcs_9_5}, {1, arcs_9_6}, {3, arcs_9_7}, {4, arcs_9_8}, {3, arcs_9_9}, {3, arcs_9_10}, {4, arcs_9_11}, {4, arcs_9_12}, {4, arcs_9_13}, {3, arcs_9_14}, {4, arcs_9_15}, {2, arcs_9_16}, {3, arcs_9_17}, {4, arcs_9_18}, {1, arcs_9_19}, {3, arcs_9_20}, {4, arcs_9_21}, {1, arcs_9_22}, }; static arc arcs_10_0[1] = { {23, 1}, }; static arc arcs_10_1[2] = { {27, 2}, {0, 1}, }; static arc arcs_10_2[1] = { {26, 3}, }; static arc arcs_10_3[1] = { {0, 3}, }; static state states_10[4] = { {1, arcs_10_0}, {2, arcs_10_1}, {1, arcs_10_2}, {1, arcs_10_3}, }; static arc arcs_11_0[3] = { {37, 1}, {34, 2}, {35, 3}, }; static arc arcs_11_1[3] = { {32, 4}, {33, 5}, {0, 1}, }; static arc arcs_11_2[3] = { {37, 6}, {33, 7}, {0, 2}, }; static arc arcs_11_3[1] = { {37, 8}, }; static arc arcs_11_4[1] = { {26, 9}, }; static arc arcs_11_5[4] = { {37, 10}, {34, 11}, {35, 3}, {0, 5}, }; static arc arcs_11_6[2] = { {33, 7}, {0, 6}, }; static arc arcs_11_7[3] = { {37, 12}, {35, 3}, {0, 7}, }; static arc arcs_11_8[2] = { {33, 13}, {0, 8}, }; static arc arcs_11_9[2] = { {33, 5}, {0, 9}, }; static arc arcs_11_10[3] = { {33, 5}, {32, 4}, {0, 10}, }; static arc arcs_11_11[3] = { {37, 14}, {33, 15}, {0, 11}, }; static arc arcs_11_12[3] = { {33, 7}, {32, 16}, {0, 12}, }; static arc arcs_11_13[1] = { {0, 13}, }; static arc arcs_11_14[2] = { {33, 15}, {0, 14}, }; static arc arcs_11_15[3] = { {37, 17}, {35, 3}, {0, 15}, }; static arc arcs_11_16[1] = { {26, 6}, }; static arc arcs_11_17[3] = { {33, 15}, {32, 18}, {0, 17}, }; static arc arcs_11_18[1] = { {26, 14}, }; static state states_11[19] = { {3, arcs_11_0}, {3, arcs_11_1}, {3, arcs_11_2}, {1, arcs_11_3}, {1, arcs_11_4}, {4, arcs_11_5}, {2, arcs_11_6}, {3, arcs_11_7}, {2, arcs_11_8}, {2, arcs_11_9}, {3, arcs_11_10}, {3, arcs_11_11}, {3, arcs_11_12}, {1, arcs_11_13}, {2, arcs_11_14}, {3, arcs_11_15}, {1, arcs_11_16}, {3, arcs_11_17}, {1, arcs_11_18}, }; static arc arcs_12_0[1] = { {23, 1}, }; static arc arcs_12_1[1] = { {0, 1}, }; static state states_12[2] = { {1, arcs_12_0}, {1, arcs_12_1}, }; static arc arcs_13_0[2] = { {3, 1}, {4, 1}, }; static arc arcs_13_1[1] = { {0, 1}, }; static state states_13[2] = { {2, arcs_13_0}, {1, arcs_13_1}, }; static arc arcs_14_0[1] = { {38, 1}, }; static arc arcs_14_1[2] = { {39, 2}, {2, 3}, }; static arc arcs_14_2[2] = { {38, 1}, {2, 3}, }; static arc arcs_14_3[1] = { {0, 3}, }; static state states_14[4] = { {1, arcs_14_0}, {2, arcs_14_1}, {2, arcs_14_2}, {1, arcs_14_3}, }; static arc arcs_15_0[8] = { {40, 1}, {41, 1}, {42, 1}, {43, 1}, {44, 1}, {45, 1}, {46, 1}, {47, 1}, }; static arc arcs_15_1[1] = { {0, 1}, }; static state states_15[2] = { {8, arcs_15_0}, {1, arcs_15_1}, }; static arc arcs_16_0[1] = { {48, 1}, }; static arc arcs_16_1[5] = { {49, 2}, {50, 3}, {32, 4}, {28, 2}, {0, 1}, }; static arc arcs_16_2[1] = { {0, 2}, }; static arc arcs_16_3[2] = { {51, 2}, {9, 2}, }; static arc arcs_16_4[2] = { {51, 5}, {48, 5}, }; static arc arcs_16_5[3] = { {32, 4}, {28, 2}, {0, 5}, }; static state states_16[6] = { {1, arcs_16_0}, {5, arcs_16_1}, {1, arcs_16_2}, {2, arcs_16_3}, {2, arcs_16_4}, {3, arcs_16_5}, }; static arc arcs_17_0[1] = { {27, 1}, }; static arc arcs_17_1[1] = { {26, 2}, }; static arc arcs_17_2[2] = { {32, 3}, {0, 2}, }; static arc arcs_17_3[1] = { {26, 4}, }; static arc arcs_17_4[1] = { {0, 4}, }; static state states_17[5] = { {1, arcs_17_0}, {1, arcs_17_1}, {2, arcs_17_2}, {1, arcs_17_3}, {1, arcs_17_4}, }; static arc arcs_18_0[2] = { {26, 1}, {52, 1}, }; static arc arcs_18_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_18_2[3] = { {26, 1}, {52, 1}, {0, 2}, }; static state states_18[3] = { {2, arcs_18_0}, {2, arcs_18_1}, {3, arcs_18_2}, }; static arc arcs_19_0[13] = { {53, 1}, {54, 1}, {55, 1}, {56, 1}, {57, 1}, {58, 1}, {59, 1}, {60, 1}, {61, 1}, {62, 1}, {63, 1}, {64, 1}, {65, 1}, }; static arc arcs_19_1[1] = { {0, 1}, }; static state states_19[2] = { {13, arcs_19_0}, {1, arcs_19_1}, }; static arc arcs_20_0[1] = { {66, 1}, }; static arc arcs_20_1[1] = { {67, 2}, }; static arc arcs_20_2[1] = { {0, 2}, }; static state states_20[3] = { {1, arcs_20_0}, {1, arcs_20_1}, {1, arcs_20_2}, }; static arc arcs_21_0[1] = { {68, 1}, }; static arc arcs_21_1[1] = { {0, 1}, }; static state states_21[2] = { {1, arcs_21_0}, {1, arcs_21_1}, }; static arc arcs_22_0[5] = { {69, 1}, {70, 1}, {71, 1}, {72, 1}, {73, 1}, }; static arc arcs_22_1[1] = { {0, 1}, }; static state states_22[2] = { {5, arcs_22_0}, {1, arcs_22_1}, }; static arc arcs_23_0[1] = { {74, 1}, }; static arc arcs_23_1[1] = { {0, 1}, }; static state states_23[2] = { {1, arcs_23_0}, {1, arcs_23_1}, }; static arc arcs_24_0[1] = { {75, 1}, }; static arc arcs_24_1[1] = { {0, 1}, }; static state states_24[2] = { {1, arcs_24_0}, {1, arcs_24_1}, }; static arc arcs_25_0[1] = { {76, 1}, }; static arc arcs_25_1[2] = { {9, 2}, {0, 1}, }; static arc arcs_25_2[1] = { {0, 2}, }; static state states_25[3] = { {1, arcs_25_0}, {2, arcs_25_1}, {1, arcs_25_2}, }; static arc arcs_26_0[1] = { {51, 1}, }; static arc arcs_26_1[1] = { {0, 1}, }; static state states_26[2] = { {1, arcs_26_0}, {1, arcs_26_1}, }; static arc arcs_27_0[1] = { {77, 1}, }; static arc arcs_27_1[2] = { {26, 2}, {0, 1}, }; static arc arcs_27_2[2] = { {78, 3}, {0, 2}, }; static arc arcs_27_3[1] = { {26, 4}, }; static arc arcs_27_4[1] = { {0, 4}, }; static state states_27[5] = { {1, arcs_27_0}, {2, arcs_27_1}, {2, arcs_27_2}, {1, arcs_27_3}, {1, arcs_27_4}, }; static arc arcs_28_0[2] = { {79, 1}, {80, 1}, }; static arc arcs_28_1[1] = { {0, 1}, }; static state states_28[2] = { {2, arcs_28_0}, {1, arcs_28_1}, }; static arc arcs_29_0[1] = { {81, 1}, }; static arc arcs_29_1[1] = { {82, 2}, }; static arc arcs_29_2[1] = { {0, 2}, }; static state states_29[3] = { {1, arcs_29_0}, {1, arcs_29_1}, {1, arcs_29_2}, }; static arc arcs_30_0[1] = { {78, 1}, }; static arc arcs_30_1[3] = { {83, 2}, {84, 2}, {12, 3}, }; static arc arcs_30_2[4] = { {83, 2}, {84, 2}, {12, 3}, {81, 4}, }; static arc arcs_30_3[1] = { {81, 4}, }; static arc arcs_30_4[3] = { {34, 5}, {13, 6}, {85, 5}, }; static arc arcs_30_5[1] = { {0, 5}, }; static arc arcs_30_6[1] = { {85, 7}, }; static arc arcs_30_7[1] = { {15, 5}, }; static state states_30[8] = { {1, arcs_30_0}, {3, arcs_30_1}, {4, arcs_30_2}, {1, arcs_30_3}, {3, arcs_30_4}, {1, arcs_30_5}, {1, arcs_30_6}, {1, arcs_30_7}, }; static arc arcs_31_0[1] = { {23, 1}, }; static arc arcs_31_1[2] = { {87, 2}, {0, 1}, }; static arc arcs_31_2[1] = { {23, 3}, }; static arc arcs_31_3[1] = { {0, 3}, }; static state states_31[4] = { {1, arcs_31_0}, {2, arcs_31_1}, {1, arcs_31_2}, {1, arcs_31_3}, }; static arc arcs_32_0[1] = { {12, 1}, }; static arc arcs_32_1[2] = { {87, 2}, {0, 1}, }; static arc arcs_32_2[1] = { {23, 3}, }; static arc arcs_32_3[1] = { {0, 3}, }; static state states_32[4] = { {1, arcs_32_0}, {2, arcs_32_1}, {1, arcs_32_2}, {1, arcs_32_3}, }; static arc arcs_33_0[1] = { {86, 1}, }; static arc arcs_33_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_33_2[2] = { {86, 1}, {0, 2}, }; static state states_33[3] = { {1, arcs_33_0}, {2, arcs_33_1}, {2, arcs_33_2}, }; static arc arcs_34_0[1] = { {88, 1}, }; static arc arcs_34_1[2] = { {33, 0}, {0, 1}, }; static state states_34[2] = { {1, arcs_34_0}, {2, arcs_34_1}, }; static arc arcs_35_0[1] = { {23, 1}, }; static arc arcs_35_1[2] = { {83, 0}, {0, 1}, }; static state states_35[2] = { {1, arcs_35_0}, {2, arcs_35_1}, }; static arc arcs_36_0[1] = { {89, 1}, }; static arc arcs_36_1[1] = { {23, 2}, }; static arc arcs_36_2[2] = { {33, 1}, {0, 2}, }; static state states_36[3] = { {1, arcs_36_0}, {1, arcs_36_1}, {2, arcs_36_2}, }; static arc arcs_37_0[1] = { {90, 1}, }; static arc arcs_37_1[1] = { {23, 2}, }; static arc arcs_37_2[2] = { {33, 1}, {0, 2}, }; static state states_37[3] = { {1, arcs_37_0}, {1, arcs_37_1}, {2, arcs_37_2}, }; static arc arcs_38_0[1] = { {91, 1}, }; static arc arcs_38_1[1] = { {26, 2}, }; static arc arcs_38_2[2] = { {33, 3}, {0, 2}, }; static arc arcs_38_3[1] = { {26, 4}, }; static arc arcs_38_4[1] = { {0, 4}, }; static state states_38[5] = { {1, arcs_38_0}, {1, arcs_38_1}, {2, arcs_38_2}, {1, arcs_38_3}, {1, arcs_38_4}, }; static arc arcs_39_0[9] = { {92, 1}, {93, 1}, {94, 1}, {95, 1}, {96, 1}, {19, 1}, {18, 1}, {17, 1}, {97, 1}, }; static arc arcs_39_1[1] = { {0, 1}, }; static state states_39[2] = { {9, arcs_39_0}, {1, arcs_39_1}, }; static arc arcs_40_0[1] = { {21, 1}, }; static arc arcs_40_1[3] = { {19, 2}, {96, 2}, {94, 2}, }; static arc arcs_40_2[1] = { {0, 2}, }; static state states_40[3] = { {1, arcs_40_0}, {3, arcs_40_1}, {1, arcs_40_2}, }; static arc arcs_41_0[1] = { {98, 1}, }; static arc arcs_41_1[1] = { {26, 2}, }; static arc arcs_41_2[1] = { {27, 3}, }; static arc arcs_41_3[1] = { {29, 4}, }; static arc arcs_41_4[3] = { {99, 1}, {100, 5}, {0, 4}, }; static arc arcs_41_5[1] = { {27, 6}, }; static arc arcs_41_6[1] = { {29, 7}, }; static arc arcs_41_7[1] = { {0, 7}, }; static state states_41[8] = { {1, arcs_41_0}, {1, arcs_41_1}, {1, arcs_41_2}, {1, arcs_41_3}, {3, arcs_41_4}, {1, arcs_41_5}, {1, arcs_41_6}, {1, arcs_41_7}, }; static arc arcs_42_0[1] = { {101, 1}, }; static arc arcs_42_1[1] = { {26, 2}, }; static arc arcs_42_2[1] = { {27, 3}, }; static arc arcs_42_3[1] = { {29, 4}, }; static arc arcs_42_4[2] = { {100, 5}, {0, 4}, }; static arc arcs_42_5[1] = { {27, 6}, }; static arc arcs_42_6[1] = { {29, 7}, }; static arc arcs_42_7[1] = { {0, 7}, }; static state states_42[8] = { {1, arcs_42_0}, {1, arcs_42_1}, {1, arcs_42_2}, {1, arcs_42_3}, {2, arcs_42_4}, {1, arcs_42_5}, {1, arcs_42_6}, {1, arcs_42_7}, }; static arc arcs_43_0[1] = { {102, 1}, }; static arc arcs_43_1[1] = { {67, 2}, }; static arc arcs_43_2[1] = { {103, 3}, }; static arc arcs_43_3[1] = { {9, 4}, }; static arc arcs_43_4[1] = { {27, 5}, }; static arc arcs_43_5[2] = { {28, 6}, {29, 7}, }; static arc arcs_43_6[1] = { {29, 7}, }; static arc arcs_43_7[2] = { {100, 8}, {0, 7}, }; static arc arcs_43_8[1] = { {27, 9}, }; static arc arcs_43_9[1] = { {29, 10}, }; static arc arcs_43_10[1] = { {0, 10}, }; static state states_43[11] = { {1, arcs_43_0}, {1, arcs_43_1}, {1, arcs_43_2}, {1, arcs_43_3}, {1, arcs_43_4}, {2, arcs_43_5}, {1, arcs_43_6}, {2, arcs_43_7}, {1, arcs_43_8}, {1, arcs_43_9}, {1, arcs_43_10}, }; static arc arcs_44_0[1] = { {104, 1}, }; static arc arcs_44_1[1] = { {27, 2}, }; static arc arcs_44_2[1] = { {29, 3}, }; static arc arcs_44_3[2] = { {105, 4}, {106, 5}, }; static arc arcs_44_4[1] = { {27, 6}, }; static arc arcs_44_5[1] = { {27, 7}, }; static arc arcs_44_6[1] = { {29, 8}, }; static arc arcs_44_7[1] = { {29, 9}, }; static arc arcs_44_8[4] = { {105, 4}, {100, 10}, {106, 5}, {0, 8}, }; static arc arcs_44_9[1] = { {0, 9}, }; static arc arcs_44_10[1] = { {27, 11}, }; static arc arcs_44_11[1] = { {29, 12}, }; static arc arcs_44_12[2] = { {106, 5}, {0, 12}, }; static state states_44[13] = { {1, arcs_44_0}, {1, arcs_44_1}, {1, arcs_44_2}, {2, arcs_44_3}, {1, arcs_44_4}, {1, arcs_44_5}, {1, arcs_44_6}, {1, arcs_44_7}, {4, arcs_44_8}, {1, arcs_44_9}, {1, arcs_44_10}, {1, arcs_44_11}, {2, arcs_44_12}, }; static arc arcs_45_0[1] = { {107, 1}, }; static arc arcs_45_1[1] = { {108, 2}, }; static arc arcs_45_2[2] = { {33, 1}, {27, 3}, }; static arc arcs_45_3[2] = { {28, 4}, {29, 5}, }; static arc arcs_45_4[1] = { {29, 5}, }; static arc arcs_45_5[1] = { {0, 5}, }; static state states_45[6] = { {1, arcs_45_0}, {1, arcs_45_1}, {2, arcs_45_2}, {2, arcs_45_3}, {1, arcs_45_4}, {1, arcs_45_5}, }; static arc arcs_46_0[1] = { {26, 1}, }; static arc arcs_46_1[2] = { {87, 2}, {0, 1}, }; static arc arcs_46_2[1] = { {109, 3}, }; static arc arcs_46_3[1] = { {0, 3}, }; static state states_46[4] = { {1, arcs_46_0}, {2, arcs_46_1}, {1, arcs_46_2}, {1, arcs_46_3}, }; static arc arcs_47_0[1] = { {110, 1}, }; static arc arcs_47_1[2] = { {26, 2}, {0, 1}, }; static arc arcs_47_2[2] = { {87, 3}, {0, 2}, }; static arc arcs_47_3[1] = { {23, 4}, }; static arc arcs_47_4[1] = { {0, 4}, }; static state states_47[5] = { {1, arcs_47_0}, {2, arcs_47_1}, {2, arcs_47_2}, {1, arcs_47_3}, {1, arcs_47_4}, }; static arc arcs_48_0[2] = { {3, 1}, {2, 2}, }; static arc arcs_48_1[1] = { {0, 1}, }; static arc arcs_48_2[2] = { {28, 3}, {111, 4}, }; static arc arcs_48_3[1] = { {2, 5}, }; static arc arcs_48_4[1] = { {6, 6}, }; static arc arcs_48_5[1] = { {111, 4}, }; static arc arcs_48_6[2] = { {6, 6}, {112, 1}, }; static state states_48[7] = { {2, arcs_48_0}, {1, arcs_48_1}, {2, arcs_48_2}, {1, arcs_48_3}, {1, arcs_48_4}, {1, arcs_48_5}, {2, arcs_48_6}, }; static arc arcs_49_0[2] = { {113, 1}, {114, 2}, }; static arc arcs_49_1[2] = { {98, 3}, {0, 1}, }; static arc arcs_49_2[1] = { {0, 2}, }; static arc arcs_49_3[1] = { {113, 4}, }; static arc arcs_49_4[1] = { {100, 5}, }; static arc arcs_49_5[1] = { {26, 2}, }; static state states_49[6] = { {2, arcs_49_0}, {2, arcs_49_1}, {1, arcs_49_2}, {1, arcs_49_3}, {1, arcs_49_4}, {1, arcs_49_5}, }; static arc arcs_50_0[2] = { {113, 1}, {116, 1}, }; static arc arcs_50_1[1] = { {0, 1}, }; static state states_50[2] = { {2, arcs_50_0}, {1, arcs_50_1}, }; static arc arcs_51_0[1] = { {117, 1}, }; static arc arcs_51_1[2] = { {36, 2}, {27, 3}, }; static arc arcs_51_2[1] = { {27, 3}, }; static arc arcs_51_3[1] = { {26, 4}, }; static arc arcs_51_4[1] = { {0, 4}, }; static state states_51[5] = { {1, arcs_51_0}, {2, arcs_51_1}, {1, arcs_51_2}, {1, arcs_51_3}, {1, arcs_51_4}, }; static arc arcs_52_0[1] = { {117, 1}, }; static arc arcs_52_1[2] = { {36, 2}, {27, 3}, }; static arc arcs_52_2[1] = { {27, 3}, }; static arc arcs_52_3[1] = { {115, 4}, }; static arc arcs_52_4[1] = { {0, 4}, }; static state states_52[5] = { {1, arcs_52_0}, {2, arcs_52_1}, {1, arcs_52_2}, {1, arcs_52_3}, {1, arcs_52_4}, }; static arc arcs_53_0[1] = { {118, 1}, }; static arc arcs_53_1[2] = { {119, 0}, {0, 1}, }; static state states_53[2] = { {1, arcs_53_0}, {2, arcs_53_1}, }; static arc arcs_54_0[1] = { {120, 1}, }; static arc arcs_54_1[2] = { {121, 0}, {0, 1}, }; static state states_54[2] = { {1, arcs_54_0}, {2, arcs_54_1}, }; static arc arcs_55_0[2] = { {122, 1}, {123, 2}, }; static arc arcs_55_1[1] = { {120, 2}, }; static arc arcs_55_2[1] = { {0, 2}, }; static state states_55[3] = { {2, arcs_55_0}, {1, arcs_55_1}, {1, arcs_55_2}, }; static arc arcs_56_0[1] = { {109, 1}, }; static arc arcs_56_1[2] = { {124, 0}, {0, 1}, }; static state states_56[2] = { {1, arcs_56_0}, {2, arcs_56_1}, }; static arc arcs_57_0[10] = { {125, 1}, {126, 1}, {127, 1}, {128, 1}, {129, 1}, {130, 1}, {131, 1}, {103, 1}, {122, 2}, {132, 3}, }; static arc arcs_57_1[1] = { {0, 1}, }; static arc arcs_57_2[1] = { {103, 1}, }; static arc arcs_57_3[2] = { {122, 1}, {0, 3}, }; static state states_57[4] = { {10, arcs_57_0}, {1, arcs_57_1}, {1, arcs_57_2}, {2, arcs_57_3}, }; static arc arcs_58_0[1] = { {34, 1}, }; static arc arcs_58_1[1] = { {109, 2}, }; static arc arcs_58_2[1] = { {0, 2}, }; static state states_58[3] = { {1, arcs_58_0}, {1, arcs_58_1}, {1, arcs_58_2}, }; static arc arcs_59_0[1] = { {133, 1}, }; static arc arcs_59_1[2] = { {134, 0}, {0, 1}, }; static state states_59[2] = { {1, arcs_59_0}, {2, arcs_59_1}, }; static arc arcs_60_0[1] = { {135, 1}, }; static arc arcs_60_1[2] = { {136, 0}, {0, 1}, }; static state states_60[2] = { {1, arcs_60_0}, {2, arcs_60_1}, }; static arc arcs_61_0[1] = { {137, 1}, }; static arc arcs_61_1[2] = { {138, 0}, {0, 1}, }; static state states_61[2] = { {1, arcs_61_0}, {2, arcs_61_1}, }; static arc arcs_62_0[1] = { {139, 1}, }; static arc arcs_62_1[3] = { {140, 0}, {141, 0}, {0, 1}, }; static state states_62[2] = { {1, arcs_62_0}, {3, arcs_62_1}, }; static arc arcs_63_0[1] = { {142, 1}, }; static arc arcs_63_1[3] = { {143, 0}, {144, 0}, {0, 1}, }; static state states_63[2] = { {1, arcs_63_0}, {3, arcs_63_1}, }; static arc arcs_64_0[1] = { {145, 1}, }; static arc arcs_64_1[6] = { {34, 0}, {11, 0}, {146, 0}, {147, 0}, {148, 0}, {0, 1}, }; static state states_64[2] = { {1, arcs_64_0}, {6, arcs_64_1}, }; static arc arcs_65_0[4] = { {143, 1}, {144, 1}, {149, 1}, {150, 2}, }; static arc arcs_65_1[1] = { {145, 2}, }; static arc arcs_65_2[1] = { {0, 2}, }; static state states_65[3] = { {4, arcs_65_0}, {1, arcs_65_1}, {1, arcs_65_2}, }; static arc arcs_66_0[1] = { {151, 1}, }; static arc arcs_66_1[2] = { {35, 2}, {0, 1}, }; static arc arcs_66_2[1] = { {145, 3}, }; static arc arcs_66_3[1] = { {0, 3}, }; static state states_66[4] = { {1, arcs_66_0}, {2, arcs_66_1}, {1, arcs_66_2}, {1, arcs_66_3}, }; static arc arcs_67_0[2] = { {152, 1}, {153, 2}, }; static arc arcs_67_1[1] = { {153, 2}, }; static arc arcs_67_2[2] = { {154, 2}, {0, 2}, }; static state states_67[3] = { {2, arcs_67_0}, {1, arcs_67_1}, {2, arcs_67_2}, }; static arc arcs_68_0[10] = { {13, 1}, {156, 2}, {158, 3}, {23, 4}, {161, 4}, {162, 5}, {84, 4}, {163, 4}, {164, 4}, {165, 4}, }; static arc arcs_68_1[3] = { {51, 6}, {155, 6}, {15, 4}, }; static arc arcs_68_2[2] = { {155, 7}, {157, 4}, }; static arc arcs_68_3[2] = { {159, 8}, {160, 4}, }; static arc arcs_68_4[1] = { {0, 4}, }; static arc arcs_68_5[2] = { {162, 5}, {0, 5}, }; static arc arcs_68_6[1] = { {15, 4}, }; static arc arcs_68_7[1] = { {157, 4}, }; static arc arcs_68_8[1] = { {160, 4}, }; static state states_68[9] = { {10, arcs_68_0}, {3, arcs_68_1}, {2, arcs_68_2}, {2, arcs_68_3}, {1, arcs_68_4}, {2, arcs_68_5}, {1, arcs_68_6}, {1, arcs_68_7}, {1, arcs_68_8}, }; static arc arcs_69_0[2] = { {26, 1}, {52, 1}, }; static arc arcs_69_1[3] = { {166, 2}, {33, 3}, {0, 1}, }; static arc arcs_69_2[1] = { {0, 2}, }; static arc arcs_69_3[3] = { {26, 4}, {52, 4}, {0, 3}, }; static arc arcs_69_4[2] = { {33, 3}, {0, 4}, }; static state states_69[5] = { {2, arcs_69_0}, {3, arcs_69_1}, {1, arcs_69_2}, {3, arcs_69_3}, {2, arcs_69_4}, }; static arc arcs_70_0[3] = { {13, 1}, {156, 2}, {83, 3}, }; static arc arcs_70_1[2] = { {14, 4}, {15, 5}, }; static arc arcs_70_2[1] = { {167, 6}, }; static arc arcs_70_3[1] = { {23, 5}, }; static arc arcs_70_4[1] = { {15, 5}, }; static arc arcs_70_5[1] = { {0, 5}, }; static arc arcs_70_6[1] = { {157, 5}, }; static state states_70[7] = { {3, arcs_70_0}, {2, arcs_70_1}, {1, arcs_70_2}, {1, arcs_70_3}, {1, arcs_70_4}, {1, arcs_70_5}, {1, arcs_70_6}, }; static arc arcs_71_0[1] = { {168, 1}, }; static arc arcs_71_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_71_2[2] = { {168, 1}, {0, 2}, }; static state states_71[3] = { {1, arcs_71_0}, {2, arcs_71_1}, {2, arcs_71_2}, }; static arc arcs_72_0[2] = { {26, 1}, {27, 2}, }; static arc arcs_72_1[2] = { {27, 2}, {0, 1}, }; static arc arcs_72_2[3] = { {26, 3}, {169, 4}, {0, 2}, }; static arc arcs_72_3[2] = { {169, 4}, {0, 3}, }; static arc arcs_72_4[1] = { {0, 4}, }; static state states_72[5] = { {2, arcs_72_0}, {2, arcs_72_1}, {3, arcs_72_2}, {2, arcs_72_3}, {1, arcs_72_4}, }; static arc arcs_73_0[1] = { {27, 1}, }; static arc arcs_73_1[2] = { {26, 2}, {0, 1}, }; static arc arcs_73_2[1] = { {0, 2}, }; static state states_73[3] = { {1, arcs_73_0}, {2, arcs_73_1}, {1, arcs_73_2}, }; static arc arcs_74_0[2] = { {109, 1}, {52, 1}, }; static arc arcs_74_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_74_2[3] = { {109, 1}, {52, 1}, {0, 2}, }; static state states_74[3] = { {2, arcs_74_0}, {2, arcs_74_1}, {3, arcs_74_2}, }; static arc arcs_75_0[1] = { {26, 1}, }; static arc arcs_75_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_75_2[2] = { {26, 1}, {0, 2}, }; static state states_75[3] = { {1, arcs_75_0}, {2, arcs_75_1}, {2, arcs_75_2}, }; static arc arcs_76_0[3] = { {26, 1}, {35, 2}, {52, 3}, }; static arc arcs_76_1[4] = { {27, 4}, {166, 5}, {33, 6}, {0, 1}, }; static arc arcs_76_2[1] = { {109, 7}, }; static arc arcs_76_3[3] = { {166, 5}, {33, 6}, {0, 3}, }; static arc arcs_76_4[1] = { {26, 7}, }; static arc arcs_76_5[1] = { {0, 5}, }; static arc arcs_76_6[3] = { {26, 8}, {52, 8}, {0, 6}, }; static arc arcs_76_7[3] = { {166, 5}, {33, 9}, {0, 7}, }; static arc arcs_76_8[2] = { {33, 6}, {0, 8}, }; static arc arcs_76_9[3] = { {26, 10}, {35, 11}, {0, 9}, }; static arc arcs_76_10[1] = { {27, 12}, }; static arc arcs_76_11[1] = { {109, 13}, }; static arc arcs_76_12[1] = { {26, 13}, }; static arc arcs_76_13[2] = { {33, 9}, {0, 13}, }; static state states_76[14] = { {3, arcs_76_0}, {4, arcs_76_1}, {1, arcs_76_2}, {3, arcs_76_3}, {1, arcs_76_4}, {1, arcs_76_5}, {3, arcs_76_6}, {3, arcs_76_7}, {2, arcs_76_8}, {3, arcs_76_9}, {1, arcs_76_10}, {1, arcs_76_11}, {1, arcs_76_12}, {2, arcs_76_13}, }; static arc arcs_77_0[1] = { {170, 1}, }; static arc arcs_77_1[1] = { {23, 2}, }; static arc arcs_77_2[2] = { {13, 3}, {27, 4}, }; static arc arcs_77_3[2] = { {14, 5}, {15, 6}, }; static arc arcs_77_4[1] = { {29, 7}, }; static arc arcs_77_5[1] = { {15, 6}, }; static arc arcs_77_6[1] = { {27, 4}, }; static arc arcs_77_7[1] = { {0, 7}, }; static state states_77[8] = { {1, arcs_77_0}, {1, arcs_77_1}, {2, arcs_77_2}, {2, arcs_77_3}, {1, arcs_77_4}, {1, arcs_77_5}, {1, arcs_77_6}, {1, arcs_77_7}, }; static arc arcs_78_0[1] = { {171, 1}, }; static arc arcs_78_1[2] = { {33, 2}, {0, 1}, }; static arc arcs_78_2[2] = { {171, 1}, {0, 2}, }; static state states_78[3] = { {1, arcs_78_0}, {2, arcs_78_1}, {2, arcs_78_2}, }; static arc arcs_79_0[3] = { {26, 1}, {35, 2}, {34, 2}, }; static arc arcs_79_1[3] = { {166, 3}, {32, 2}, {0, 1}, }; static arc arcs_79_2[1] = { {26, 3}, }; static arc arcs_79_3[1] = { {0, 3}, }; static state states_79[4] = { {3, arcs_79_0}, {3, arcs_79_1}, {1, arcs_79_2}, {1, arcs_79_3}, }; static arc arcs_80_0[2] = { {166, 1}, {173, 1}, }; static arc arcs_80_1[1] = { {0, 1}, }; static state states_80[2] = { {2, arcs_80_0}, {1, arcs_80_1}, }; static arc arcs_81_0[2] = { {21, 1}, {102, 2}, }; static arc arcs_81_1[1] = { {102, 2}, }; static arc arcs_81_2[1] = { {67, 3}, }; static arc arcs_81_3[1] = { {103, 4}, }; static arc arcs_81_4[1] = { {113, 5}, }; static arc arcs_81_5[2] = { {172, 6}, {0, 5}, }; static arc arcs_81_6[1] = { {0, 6}, }; static state states_81[7] = { {2, arcs_81_0}, {1, arcs_81_1}, {1, arcs_81_2}, {1, arcs_81_3}, {1, arcs_81_4}, {2, arcs_81_5}, {1, arcs_81_6}, }; static arc arcs_82_0[1] = { {98, 1}, }; static arc arcs_82_1[1] = { {115, 2}, }; static arc arcs_82_2[2] = { {172, 3}, {0, 2}, }; static arc arcs_82_3[1] = { {0, 3}, }; static state states_82[4] = { {1, arcs_82_0}, {1, arcs_82_1}, {2, arcs_82_2}, {1, arcs_82_3}, }; static arc arcs_83_0[1] = { {23, 1}, }; static arc arcs_83_1[1] = { {0, 1}, }; static state states_83[2] = { {1, arcs_83_0}, {1, arcs_83_1}, }; static arc arcs_84_0[1] = { {175, 1}, }; static arc arcs_84_1[2] = { {176, 2}, {0, 1}, }; static arc arcs_84_2[1] = { {0, 2}, }; static state states_84[3] = { {1, arcs_84_0}, {2, arcs_84_1}, {1, arcs_84_2}, }; static arc arcs_85_0[2] = { {78, 1}, {9, 2}, }; static arc arcs_85_1[1] = { {26, 2}, }; static arc arcs_85_2[1] = { {0, 2}, }; static state states_85[3] = { {2, arcs_85_0}, {1, arcs_85_1}, {1, arcs_85_2}, }; static arc arcs_86_0[1] = { {178, 1}, }; static arc arcs_86_1[2] = { {2, 1}, {7, 2}, }; static arc arcs_86_2[1] = { {0, 2}, }; static state states_86[3] = { {1, arcs_86_0}, {2, arcs_86_1}, {1, arcs_86_2}, }; static arc arcs_87_0[1] = { {13, 1}, }; static arc arcs_87_1[2] = { {179, 2}, {15, 3}, }; static arc arcs_87_2[1] = { {15, 3}, }; static arc arcs_87_3[1] = { {25, 4}, }; static arc arcs_87_4[1] = { {26, 5}, }; static arc arcs_87_5[1] = { {0, 5}, }; static state states_87[6] = { {1, arcs_87_0}, {2, arcs_87_1}, {1, arcs_87_2}, {1, arcs_87_3}, {1, arcs_87_4}, {1, arcs_87_5}, }; static arc arcs_88_0[3] = { {26, 1}, {34, 2}, {35, 3}, }; static arc arcs_88_1[2] = { {33, 4}, {0, 1}, }; static arc arcs_88_2[3] = { {26, 5}, {33, 6}, {0, 2}, }; static arc arcs_88_3[1] = { {26, 7}, }; static arc arcs_88_4[4] = { {26, 1}, {34, 8}, {35, 3}, {0, 4}, }; static arc arcs_88_5[2] = { {33, 6}, {0, 5}, }; static arc arcs_88_6[2] = { {26, 5}, {35, 3}, }; static arc arcs_88_7[1] = { {0, 7}, }; static arc arcs_88_8[3] = { {26, 9}, {33, 10}, {0, 8}, }; static arc arcs_88_9[2] = { {33, 10}, {0, 9}, }; static arc arcs_88_10[2] = { {26, 9}, {35, 3}, }; static state states_88[11] = { {3, arcs_88_0}, {2, arcs_88_1}, {3, arcs_88_2}, {1, arcs_88_3}, {4, arcs_88_4}, {2, arcs_88_5}, {2, arcs_88_6}, {1, arcs_88_7}, {3, arcs_88_8}, {2, arcs_88_9}, {2, arcs_88_10}, }; static dfa dfas[89] = { {256, "single_input", 0, 3, states_0, "\004\050\340\000\004\000\000\000\024\174\022\016\144\011\040\004\000\200\041\121\076\204\000"}, {257, "file_input", 0, 2, states_1, "\204\050\340\000\004\000\000\000\024\174\022\016\144\011\040\004\000\200\041\121\076\204\000"}, {258, "eval_input", 0, 3, states_2, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {259, "decorator", 0, 7, states_3, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {260, "decorators", 0, 2, states_4, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {261, "decorated", 0, 3, states_5, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {262, "async_funcdef", 0, 3, states_6, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {263, "funcdef", 0, 9, states_7, "\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {264, "parameters", 0, 4, states_8, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {265, "typedargslist", 0, 23, states_9, "\000\000\200\000\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {266, "tfpdef", 0, 4, states_10, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {267, "varargslist", 0, 19, states_11, "\000\000\200\000\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {268, "vfpdef", 0, 2, states_12, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {269, "stmt", 0, 2, states_13, "\000\050\340\000\004\000\000\000\024\174\022\016\144\011\040\004\000\200\041\121\076\204\000"}, {270, "simple_stmt", 0, 4, states_14, "\000\040\200\000\004\000\000\000\024\174\022\016\000\000\040\004\000\200\041\121\076\200\000"}, {271, "small_stmt", 0, 2, states_15, "\000\040\200\000\004\000\000\000\024\174\022\016\000\000\040\004\000\200\041\121\076\200\000"}, {272, "expr_stmt", 0, 6, states_16, "\000\040\200\000\004\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {273, "annassign", 0, 5, states_17, "\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {274, "testlist_star_expr", 0, 3, states_18, "\000\040\200\000\004\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {275, "augassign", 0, 2, states_19, "\000\000\000\000\000\000\340\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {276, "del_stmt", 0, 3, states_20, "\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {277, "pass_stmt", 0, 2, states_21, "\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {278, "flow_stmt", 0, 2, states_22, "\000\000\000\000\000\000\000\000\000\074\000\000\000\000\000\000\000\000\000\000\000\200\000"}, {279, "break_stmt", 0, 2, states_23, "\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {280, "continue_stmt", 0, 2, states_24, "\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {281, "return_stmt", 0, 3, states_25, "\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {282, "yield_stmt", 0, 2, states_26, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000"}, {283, "raise_stmt", 0, 5, states_27, "\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {284, "import_stmt", 0, 2, states_28, "\000\000\000\000\000\000\000\000\000\100\002\000\000\000\000\000\000\000\000\000\000\000\000"}, {285, "import_name", 0, 3, states_29, "\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000"}, {286, "import_from", 0, 8, states_30, "\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {287, "import_as_name", 0, 4, states_31, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {288, "dotted_as_name", 0, 4, states_32, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {289, "import_as_names", 0, 3, states_33, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {290, "dotted_as_names", 0, 2, states_34, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {291, "dotted_name", 0, 2, states_35, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {292, "global_stmt", 0, 3, states_36, "\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000"}, {293, "nonlocal_stmt", 0, 3, states_37, "\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000"}, {294, "assert_stmt", 0, 5, states_38, "\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000"}, {295, "compound_stmt", 0, 2, states_39, "\000\010\140\000\000\000\000\000\000\000\000\000\144\011\000\000\000\000\000\000\000\004\000"}, {296, "async_stmt", 0, 3, states_40, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {297, "if_stmt", 0, 8, states_41, "\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000"}, {298, "while_stmt", 0, 8, states_42, "\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000"}, {299, "for_stmt", 0, 11, states_43, "\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000"}, {300, "try_stmt", 0, 13, states_44, "\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000"}, {301, "with_stmt", 0, 6, states_45, "\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000"}, {302, "with_item", 0, 4, states_46, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {303, "except_clause", 0, 5, states_47, "\000\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000"}, {304, "suite", 0, 7, states_48, "\004\040\200\000\004\000\000\000\024\174\022\016\000\000\040\004\000\200\041\121\076\200\000"}, {305, "test", 0, 6, states_49, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {306, "test_nocond", 0, 2, states_50, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {307, "lambdef", 0, 5, states_51, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000"}, {308, "lambdef_nocond", 0, 5, states_52, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000"}, {309, "or_test", 0, 2, states_53, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\004\000\200\041\121\076\000\000"}, {310, "and_test", 0, 2, states_54, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\004\000\200\041\121\076\000\000"}, {311, "not_test", 0, 3, states_55, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\004\000\200\041\121\076\000\000"}, {312, "comparison", 0, 2, states_56, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {313, "comp_op", 0, 4, states_57, "\000\000\000\000\000\000\000\000\000\000\000\000\200\000\000\344\037\000\000\000\000\000\000"}, {314, "star_expr", 0, 3, states_58, "\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {315, "expr", 0, 2, states_59, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {316, "xor_expr", 0, 2, states_60, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {317, "and_expr", 0, 2, states_61, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {318, "shift_expr", 0, 2, states_62, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {319, "arith_expr", 0, 2, states_63, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {320, "term", 0, 2, states_64, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {321, "factor", 0, 3, states_65, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {322, "power", 0, 4, states_66, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\121\076\000\000"}, {323, "atom_expr", 0, 3, states_67, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\121\076\000\000"}, {324, "atom", 0, 9, states_68, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\120\076\000\000"}, {325, "testlist_comp", 0, 5, states_69, "\000\040\200\000\004\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {326, "trailer", 0, 7, states_70, "\000\040\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\020\000\000\000"}, {327, "subscriptlist", 0, 3, states_71, "\000\040\200\010\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {328, "subscript", 0, 5, states_72, "\000\040\200\010\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {329, "sliceop", 0, 3, states_73, "\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {330, "exprlist", 0, 3, states_74, "\000\040\200\000\004\000\000\000\000\000\020\000\000\000\000\000\000\200\041\121\076\000\000"}, {331, "testlist", 0, 3, states_75, "\000\040\200\000\000\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {332, "dictorsetmaker", 0, 14, states_76, "\000\040\200\000\014\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {333, "classdef", 0, 8, states_77, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000"}, {334, "arglist", 0, 3, states_78, "\000\040\200\000\014\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {335, "argument", 0, 4, states_79, "\000\040\200\000\014\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {336, "comp_iter", 0, 2, states_80, "\000\000\040\000\000\000\000\000\000\000\000\000\104\000\000\000\000\000\000\000\000\000\000"}, {337, "comp_for", 0, 7, states_81, "\000\000\040\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000"}, {338, "comp_if", 0, 4, states_82, "\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000"}, {339, "encoding_decl", 0, 2, states_83, "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {340, "yield_expr", 0, 3, states_84, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000"}, {341, "yield_arg", 0, 3, states_85, "\000\040\200\000\000\000\000\000\000\100\020\000\000\000\040\004\000\200\041\121\076\000\000"}, {342, "func_type_input", 0, 3, states_86, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {343, "func_type", 0, 6, states_87, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {344, "typelist", 0, 11, states_88, "\000\040\200\000\014\000\000\000\000\000\020\000\000\000\040\004\000\200\041\121\076\000\000"}, }; static label labels[180] = { {0, "EMPTY"}, {256, 0}, {4, 0}, {270, 0}, {295, 0}, {257, 0}, {269, 0}, {0, 0}, {258, 0}, {331, 0}, {259, 0}, {49, 0}, {291, 0}, {7, 0}, {334, 0}, {8, 0}, {260, 0}, {261, 0}, {333, 0}, {263, 0}, {262, 0}, {55, 0}, {1, "def"}, {1, 0}, {264, 0}, {51, 0}, {305, 0}, {11, 0}, {57, 0}, {304, 0}, {265, 0}, {266, 0}, {22, 0}, {12, 0}, {16, 0}, {35, 0}, {267, 0}, {268, 0}, {271, 0}, {13, 0}, {272, 0}, {276, 0}, {277, 0}, {278, 0}, {284, 0}, {292, 0}, {293, 0}, {294, 0}, {274, 0}, {273, 0}, {275, 0}, {340, 0}, {314, 0}, {36, 0}, {37, 0}, {38, 0}, {50, 0}, {39, 0}, {40, 0}, {41, 0}, {42, 0}, {43, 0}, {44, 0}, {45, 0}, {46, 0}, {48, 0}, {1, "del"}, {330, 0}, {1, "pass"}, {279, 0}, {280, 0}, {281, 0}, {283, 0}, {282, 0}, {1, "break"}, {1, "continue"}, {1, "return"}, {1, "raise"}, {1, "from"}, {285, 0}, {286, 0}, {1, "import"}, {290, 0}, {23, 0}, {52, 0}, {289, 0}, {287, 0}, {1, "as"}, {288, 0}, {1, "global"}, {1, "nonlocal"}, {1, "assert"}, {297, 0}, {298, 0}, {299, 0}, {300, 0}, {301, 0}, {296, 0}, {1, "if"}, {1, "elif"}, {1, "else"}, {1, "while"}, {1, "for"}, {1, "in"}, {1, "try"}, {303, 0}, {1, "finally"}, {1, "with"}, {302, 0}, {315, 0}, {1, "except"}, {5, 0}, {6, 0}, {309, 0}, {307, 0}, {306, 0}, {308, 0}, {1, "lambda"}, {310, 0}, {1, "or"}, {311, 0}, {1, "and"}, {1, "not"}, {312, 0}, {313, 0}, {20, 0}, {21, 0}, {27, 0}, {30, 0}, {29, 0}, {28, 0}, {28, 0}, {1, "is"}, {316, 0}, {18, 0}, {317, 0}, {32, 0}, {318, 0}, {19, 0}, {319, 0}, {33, 0}, {34, 0}, {320, 0}, {14, 0}, {15, 0}, {321, 0}, {17, 0}, {24, 0}, {47, 0}, {31, 0}, {322, 0}, {323, 0}, {54, 0}, {324, 0}, {326, 0}, {325, 0}, {9, 0}, {10, 0}, {25, 0}, {332, 0}, {26, 0}, {2, 0}, {3, 0}, {1, "None"}, {1, "True"}, {1, "False"}, {337, 0}, {327, 0}, {328, 0}, {329, 0}, {1, "class"}, {335, 0}, {336, 0}, {338, 0}, {339, 0}, {1, "yield"}, {341, 0}, {342, 0}, {343, 0}, {344, 0}, }; grammar _Ta3Parser_Grammar = { 89, dfas, {180, labels}, 256 }; typed-ast-1.1.0/ast3/Python/Python-ast.c0000644€Tøžæ€2›s®0000105143613050212017021266 0ustar ddfisher00000000000000/* File automatically generated by Parser/asdl_c.py. */ #include #include "Python.h" #include "Python-ast.h" static PyTypeObject AST_type; static PyTypeObject *mod_type; static PyObject* ast2obj_mod(void*); static PyTypeObject *Module_type; _Py_IDENTIFIER(body); _Py_IDENTIFIER(type_ignores); static char *Module_fields[]={ "body", "type_ignores", }; static PyTypeObject *Interactive_type; static char *Interactive_fields[]={ "body", }; static PyTypeObject *Expression_type; static char *Expression_fields[]={ "body", }; static PyTypeObject *FunctionType_type; _Py_IDENTIFIER(argtypes); _Py_IDENTIFIER(returns); static char *FunctionType_fields[]={ "argtypes", "returns", }; static PyTypeObject *Suite_type; static char *Suite_fields[]={ "body", }; static PyTypeObject *stmt_type; _Py_IDENTIFIER(lineno); _Py_IDENTIFIER(col_offset); static char *stmt_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_stmt(void*); static PyTypeObject *FunctionDef_type; _Py_IDENTIFIER(name); _Py_IDENTIFIER(args); _Py_IDENTIFIER(decorator_list); _Py_IDENTIFIER(type_comment); static char *FunctionDef_fields[]={ "name", "args", "body", "decorator_list", "returns", "type_comment", }; static PyTypeObject *AsyncFunctionDef_type; static char *AsyncFunctionDef_fields[]={ "name", "args", "body", "decorator_list", "returns", "type_comment", }; static PyTypeObject *ClassDef_type; _Py_IDENTIFIER(bases); _Py_IDENTIFIER(keywords); static char *ClassDef_fields[]={ "name", "bases", "keywords", "body", "decorator_list", }; static PyTypeObject *Return_type; _Py_IDENTIFIER(value); static char *Return_fields[]={ "value", }; static PyTypeObject *Delete_type; _Py_IDENTIFIER(targets); static char *Delete_fields[]={ "targets", }; static PyTypeObject *Assign_type; static char *Assign_fields[]={ "targets", "value", "type_comment", }; static PyTypeObject *AugAssign_type; _Py_IDENTIFIER(target); _Py_IDENTIFIER(op); static char *AugAssign_fields[]={ "target", "op", "value", }; static PyTypeObject *AnnAssign_type; _Py_IDENTIFIER(annotation); _Py_IDENTIFIER(simple); static char *AnnAssign_fields[]={ "target", "annotation", "value", "simple", }; static PyTypeObject *For_type; _Py_IDENTIFIER(iter); _Py_IDENTIFIER(orelse); static char *For_fields[]={ "target", "iter", "body", "orelse", "type_comment", }; static PyTypeObject *AsyncFor_type; static char *AsyncFor_fields[]={ "target", "iter", "body", "orelse", "type_comment", }; static PyTypeObject *While_type; _Py_IDENTIFIER(test); static char *While_fields[]={ "test", "body", "orelse", }; static PyTypeObject *If_type; static char *If_fields[]={ "test", "body", "orelse", }; static PyTypeObject *With_type; _Py_IDENTIFIER(items); static char *With_fields[]={ "items", "body", "type_comment", }; static PyTypeObject *AsyncWith_type; static char *AsyncWith_fields[]={ "items", "body", "type_comment", }; static PyTypeObject *Raise_type; _Py_IDENTIFIER(exc); _Py_IDENTIFIER(cause); static char *Raise_fields[]={ "exc", "cause", }; static PyTypeObject *Try_type; _Py_IDENTIFIER(handlers); _Py_IDENTIFIER(finalbody); static char *Try_fields[]={ "body", "handlers", "orelse", "finalbody", }; static PyTypeObject *Assert_type; _Py_IDENTIFIER(msg); static char *Assert_fields[]={ "test", "msg", }; static PyTypeObject *Import_type; _Py_IDENTIFIER(names); static char *Import_fields[]={ "names", }; static PyTypeObject *ImportFrom_type; _Py_IDENTIFIER(module); _Py_IDENTIFIER(level); static char *ImportFrom_fields[]={ "module", "names", "level", }; static PyTypeObject *Global_type; static char *Global_fields[]={ "names", }; static PyTypeObject *Nonlocal_type; static char *Nonlocal_fields[]={ "names", }; static PyTypeObject *Expr_type; static char *Expr_fields[]={ "value", }; static PyTypeObject *Pass_type; static PyTypeObject *Break_type; static PyTypeObject *Continue_type; static PyTypeObject *expr_type; static char *expr_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_expr(void*); static PyTypeObject *BoolOp_type; _Py_IDENTIFIER(values); static char *BoolOp_fields[]={ "op", "values", }; static PyTypeObject *BinOp_type; _Py_IDENTIFIER(left); _Py_IDENTIFIER(right); static char *BinOp_fields[]={ "left", "op", "right", }; static PyTypeObject *UnaryOp_type; _Py_IDENTIFIER(operand); static char *UnaryOp_fields[]={ "op", "operand", }; static PyTypeObject *Lambda_type; static char *Lambda_fields[]={ "args", "body", }; static PyTypeObject *IfExp_type; static char *IfExp_fields[]={ "test", "body", "orelse", }; static PyTypeObject *Dict_type; _Py_IDENTIFIER(keys); static char *Dict_fields[]={ "keys", "values", }; static PyTypeObject *Set_type; _Py_IDENTIFIER(elts); static char *Set_fields[]={ "elts", }; static PyTypeObject *ListComp_type; _Py_IDENTIFIER(elt); _Py_IDENTIFIER(generators); static char *ListComp_fields[]={ "elt", "generators", }; static PyTypeObject *SetComp_type; static char *SetComp_fields[]={ "elt", "generators", }; static PyTypeObject *DictComp_type; _Py_IDENTIFIER(key); static char *DictComp_fields[]={ "key", "value", "generators", }; static PyTypeObject *GeneratorExp_type; static char *GeneratorExp_fields[]={ "elt", "generators", }; static PyTypeObject *Await_type; static char *Await_fields[]={ "value", }; static PyTypeObject *Yield_type; static char *Yield_fields[]={ "value", }; static PyTypeObject *YieldFrom_type; static char *YieldFrom_fields[]={ "value", }; static PyTypeObject *Compare_type; _Py_IDENTIFIER(ops); _Py_IDENTIFIER(comparators); static char *Compare_fields[]={ "left", "ops", "comparators", }; static PyTypeObject *Call_type; _Py_IDENTIFIER(func); static char *Call_fields[]={ "func", "args", "keywords", }; static PyTypeObject *Num_type; _Py_IDENTIFIER(n); static char *Num_fields[]={ "n", }; static PyTypeObject *Str_type; _Py_IDENTIFIER(s); static char *Str_fields[]={ "s", }; static PyTypeObject *FormattedValue_type; _Py_IDENTIFIER(conversion); _Py_IDENTIFIER(format_spec); static char *FormattedValue_fields[]={ "value", "conversion", "format_spec", }; static PyTypeObject *JoinedStr_type; static char *JoinedStr_fields[]={ "values", }; static PyTypeObject *Bytes_type; static char *Bytes_fields[]={ "s", }; static PyTypeObject *NameConstant_type; static char *NameConstant_fields[]={ "value", }; static PyTypeObject *Ellipsis_type; static PyTypeObject *Constant_type; static char *Constant_fields[]={ "value", }; static PyTypeObject *Attribute_type; _Py_IDENTIFIER(attr); _Py_IDENTIFIER(ctx); static char *Attribute_fields[]={ "value", "attr", "ctx", }; static PyTypeObject *Subscript_type; _Py_IDENTIFIER(slice); static char *Subscript_fields[]={ "value", "slice", "ctx", }; static PyTypeObject *Starred_type; static char *Starred_fields[]={ "value", "ctx", }; static PyTypeObject *Name_type; _Py_IDENTIFIER(id); static char *Name_fields[]={ "id", "ctx", }; static PyTypeObject *List_type; static char *List_fields[]={ "elts", "ctx", }; static PyTypeObject *Tuple_type; static char *Tuple_fields[]={ "elts", "ctx", }; static PyTypeObject *expr_context_type; static PyObject *Load_singleton, *Store_singleton, *Del_singleton, *AugLoad_singleton, *AugStore_singleton, *Param_singleton; static PyObject* ast2obj_expr_context(expr_context_ty); static PyTypeObject *Load_type; static PyTypeObject *Store_type; static PyTypeObject *Del_type; static PyTypeObject *AugLoad_type; static PyTypeObject *AugStore_type; static PyTypeObject *Param_type; static PyTypeObject *slice_type; static PyObject* ast2obj_slice(void*); static PyTypeObject *Slice_type; _Py_IDENTIFIER(lower); _Py_IDENTIFIER(upper); _Py_IDENTIFIER(step); static char *Slice_fields[]={ "lower", "upper", "step", }; static PyTypeObject *ExtSlice_type; _Py_IDENTIFIER(dims); static char *ExtSlice_fields[]={ "dims", }; static PyTypeObject *Index_type; static char *Index_fields[]={ "value", }; static PyTypeObject *boolop_type; static PyObject *And_singleton, *Or_singleton; static PyObject* ast2obj_boolop(boolop_ty); static PyTypeObject *And_type; static PyTypeObject *Or_type; static PyTypeObject *operator_type; static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton, *MatMult_singleton, *Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton, *RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton, *FloorDiv_singleton; static PyObject* ast2obj_operator(operator_ty); static PyTypeObject *Add_type; static PyTypeObject *Sub_type; static PyTypeObject *Mult_type; static PyTypeObject *MatMult_type; static PyTypeObject *Div_type; static PyTypeObject *Mod_type; static PyTypeObject *Pow_type; static PyTypeObject *LShift_type; static PyTypeObject *RShift_type; static PyTypeObject *BitOr_type; static PyTypeObject *BitXor_type; static PyTypeObject *BitAnd_type; static PyTypeObject *FloorDiv_type; static PyTypeObject *unaryop_type; static PyObject *Invert_singleton, *Not_singleton, *UAdd_singleton, *USub_singleton; static PyObject* ast2obj_unaryop(unaryop_ty); static PyTypeObject *Invert_type; static PyTypeObject *Not_type; static PyTypeObject *UAdd_type; static PyTypeObject *USub_type; static PyTypeObject *cmpop_type; static PyObject *Eq_singleton, *NotEq_singleton, *Lt_singleton, *LtE_singleton, *Gt_singleton, *GtE_singleton, *Is_singleton, *IsNot_singleton, *In_singleton, *NotIn_singleton; static PyObject* ast2obj_cmpop(cmpop_ty); static PyTypeObject *Eq_type; static PyTypeObject *NotEq_type; static PyTypeObject *Lt_type; static PyTypeObject *LtE_type; static PyTypeObject *Gt_type; static PyTypeObject *GtE_type; static PyTypeObject *Is_type; static PyTypeObject *IsNot_type; static PyTypeObject *In_type; static PyTypeObject *NotIn_type; static PyTypeObject *comprehension_type; static PyObject* ast2obj_comprehension(void*); _Py_IDENTIFIER(ifs); _Py_IDENTIFIER(is_async); static char *comprehension_fields[]={ "target", "iter", "ifs", "is_async", }; static PyTypeObject *excepthandler_type; static char *excepthandler_attributes[] = { "lineno", "col_offset", }; static PyObject* ast2obj_excepthandler(void*); static PyTypeObject *ExceptHandler_type; _Py_IDENTIFIER(type); static char *ExceptHandler_fields[]={ "type", "name", "body", }; static PyTypeObject *arguments_type; static PyObject* ast2obj_arguments(void*); _Py_IDENTIFIER(vararg); _Py_IDENTIFIER(kwonlyargs); _Py_IDENTIFIER(kw_defaults); _Py_IDENTIFIER(kwarg); _Py_IDENTIFIER(defaults); static char *arguments_fields[]={ "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults", }; static PyTypeObject *arg_type; static PyObject* ast2obj_arg(void*); static char *arg_attributes[] = { "lineno", "col_offset", }; _Py_IDENTIFIER(arg); static char *arg_fields[]={ "arg", "annotation", "type_comment", }; static PyTypeObject *keyword_type; static PyObject* ast2obj_keyword(void*); static char *keyword_fields[]={ "arg", "value", }; static PyTypeObject *alias_type; static PyObject* ast2obj_alias(void*); _Py_IDENTIFIER(asname); static char *alias_fields[]={ "name", "asname", }; static PyTypeObject *withitem_type; static PyObject* ast2obj_withitem(void*); _Py_IDENTIFIER(context_expr); _Py_IDENTIFIER(optional_vars); static char *withitem_fields[]={ "context_expr", "optional_vars", }; static PyTypeObject *type_ignore_type; static PyObject* ast2obj_type_ignore(void*); static PyTypeObject *TypeIgnore_type; static char *TypeIgnore_fields[]={ "lineno", }; typedef struct { PyObject_HEAD PyObject *dict; } AST_object; static void ast_dealloc(AST_object *self) { Py_CLEAR(self->dict); Py_TYPE(self)->tp_free(self); } static int ast_traverse(AST_object *self, visitproc visit, void *arg) { Py_VISIT(self->dict); return 0; } static void ast_clear(AST_object *self) { Py_CLEAR(self->dict); } static int ast_type_init(PyObject *self, PyObject *args, PyObject *kw) { _Py_IDENTIFIER(_fields); Py_ssize_t i, numfields = 0; int res = -1; PyObject *key, *value, *fields; fields = _PyObject_GetAttrId((PyObject*)Py_TYPE(self), &PyId__fields); if (!fields) PyErr_Clear(); if (fields) { numfields = PySequence_Size(fields); if (numfields == -1) goto cleanup; } res = 0; /* if no error occurs, this stays 0 to the end */ if (PyTuple_GET_SIZE(args) > 0) { if (numfields != PyTuple_GET_SIZE(args)) { PyErr_Format(PyExc_TypeError, "%.400s constructor takes %s" "%zd positional argument%s", Py_TYPE(self)->tp_name, numfields == 0 ? "" : "either 0 or ", numfields, numfields == 1 ? "" : "s"); res = -1; goto cleanup; } for (i = 0; i < PyTuple_GET_SIZE(args); i++) { /* cannot be reached when fields is NULL */ PyObject *name = PySequence_GetItem(fields, i); if (!name) { res = -1; goto cleanup; } res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i)); Py_DECREF(name); if (res < 0) goto cleanup; } } if (kw) { i = 0; /* needed by PyDict_Next */ while (PyDict_Next(kw, &i, &key, &value)) { res = PyObject_SetAttr(self, key, value); if (res < 0) goto cleanup; } } cleanup: Py_XDECREF(fields); return res; } /* Pickling support */ static PyObject * ast_type_reduce(PyObject *self, PyObject *unused) { PyObject *res; _Py_IDENTIFIER(__dict__); PyObject *dict = _PyObject_GetAttrId(self, &PyId___dict__); if (dict == NULL) { if (PyErr_ExceptionMatches(PyExc_AttributeError)) PyErr_Clear(); else return NULL; } if (dict) { res = Py_BuildValue("O()O", Py_TYPE(self), dict); Py_DECREF(dict); return res; } return Py_BuildValue("O()", Py_TYPE(self)); } static PyMethodDef ast_type_methods[] = { {"__reduce__", ast_type_reduce, METH_NOARGS, NULL}, {NULL} }; static PyGetSetDef ast_type_getsets[] = { {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict}, {NULL} }; static PyTypeObject AST_type = { PyVarObject_HEAD_INIT(NULL, 0) "_ast3.AST", sizeof(AST_object), 0, (destructor)ast_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ PyObject_GenericSetAttr, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ 0, /* tp_doc */ (traverseproc)ast_traverse, /* tp_traverse */ (inquiry)ast_clear, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ ast_type_methods, /* tp_methods */ 0, /* tp_members */ ast_type_getsets, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ offsetof(AST_object, dict),/* tp_dictoffset */ (initproc)ast_type_init, /* tp_init */ PyType_GenericAlloc, /* tp_alloc */ PyType_GenericNew, /* tp_new */ PyObject_GC_Del, /* tp_free */ }; static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int num_fields) { PyObject *fnames, *result; int i; fnames = PyTuple_New(num_fields); if (!fnames) return NULL; for (i = 0; i < num_fields; i++) { PyObject *field = PyUnicode_FromString(fields[i]); if (!field) { Py_DECREF(fnames); return NULL; } PyTuple_SET_ITEM(fnames, i, field); } result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}", type, base, "_fields", fnames, "__module__", "_ast3"); Py_DECREF(fnames); return (PyTypeObject*)result; } static int add_attributes(PyTypeObject* type, char**attrs, int num_fields) { int i, result; _Py_IDENTIFIER(_attributes); PyObject *s, *l = PyTuple_New(num_fields); if (!l) return 0; for (i = 0; i < num_fields; i++) { s = PyUnicode_FromString(attrs[i]); if (!s) { Py_DECREF(l); return 0; } PyTuple_SET_ITEM(l, i, s); } result = _PyObject_SetAttrId((PyObject*)type, &PyId__attributes, l) >= 0; Py_DECREF(l); return result; } /* Conversion AST -> Python */ static PyObject* ast2obj_list(asdl_seq *seq, PyObject* (*func)(void*)) { Py_ssize_t i, n = asdl_seq_LEN(seq); PyObject *result = PyList_New(n); PyObject *value; if (!result) return NULL; for (i = 0; i < n; i++) { value = func(asdl_seq_GET(seq, i)); if (!value) { Py_DECREF(result); return NULL; } PyList_SET_ITEM(result, i, value); } return result; } static PyObject* ast2obj_object(void *o) { if (!o) o = Py_None; Py_INCREF((PyObject*)o); return (PyObject*)o; } #define ast2obj_singleton ast2obj_object #define ast2obj_constant ast2obj_object #define ast2obj_identifier ast2obj_object #define ast2obj_string ast2obj_object #define ast2obj_bytes ast2obj_object static PyObject* ast2obj_int(long b) { return PyLong_FromLong(b); } /* Conversion Python -> AST */ static int obj2ast_singleton(PyObject *obj, PyObject** out, PyArena* arena) { if (obj != Py_None && obj != Py_True && obj != Py_False) { PyErr_SetString(PyExc_ValueError, "AST singleton must be True, False, or None"); return 1; } *out = obj; return 0; } static int obj2ast_object(PyObject* obj, PyObject** out, PyArena* arena) { if (obj == Py_None) obj = NULL; if (obj) { if (PyArena_AddPyObject(arena, obj) < 0) { *out = NULL; return -1; } Py_INCREF(obj); } *out = obj; return 0; } static int obj2ast_constant(PyObject* obj, PyObject** out, PyArena* arena) { if (obj) { if (PyArena_AddPyObject(arena, obj) < 0) { *out = NULL; return -1; } Py_INCREF(obj); } *out = obj; return 0; } static int obj2ast_identifier(PyObject* obj, PyObject** out, PyArena* arena) { if (!PyUnicode_CheckExact(obj) && obj != Py_None) { PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str"); return 1; } return obj2ast_object(obj, out, arena); } static int obj2ast_string(PyObject* obj, PyObject** out, PyArena* arena) { if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) { PyErr_SetString(PyExc_TypeError, "AST string must be of type str"); return 1; } return obj2ast_object(obj, out, arena); } static int obj2ast_bytes(PyObject* obj, PyObject** out, PyArena* arena) { if (!PyBytes_CheckExact(obj)) { PyErr_SetString(PyExc_TypeError, "AST bytes must be of type bytes"); return 1; } return obj2ast_object(obj, out, arena); } static int obj2ast_int(PyObject* obj, int* out, PyArena* arena) { int i; if (!PyLong_Check(obj)) { PyErr_Format(PyExc_ValueError, "invalid integer value: %R", obj); return 1; } i = _PyLong_AsInt(obj); if (i == -1 && PyErr_Occurred()) return 1; *out = i; return 0; } static int add_ast_fields(void) { PyObject *empty_tuple, *d; if (PyType_Ready(&AST_type) < 0) return -1; d = AST_type.tp_dict; empty_tuple = PyTuple_New(0); if (!empty_tuple || PyDict_SetItemString(d, "_fields", empty_tuple) < 0 || PyDict_SetItemString(d, "_attributes", empty_tuple) < 0) { Py_XDECREF(empty_tuple); return -1; } Py_DECREF(empty_tuple); return 0; } static int exists_not_none(PyObject *obj, _Py_Identifier *id) { int isnone; PyObject *attr = _PyObject_GetAttrId(obj, id); if (!attr) { PyErr_Clear(); return 0; } isnone = attr == Py_None; Py_DECREF(attr); return !isnone; } static int init_types(void) { static int initialized; if (initialized) return 1; if (add_ast_fields() < 0) return 0; mod_type = make_type("mod", &AST_type, NULL, 0); if (!mod_type) return 0; if (!add_attributes(mod_type, NULL, 0)) return 0; Module_type = make_type("Module", mod_type, Module_fields, 2); if (!Module_type) return 0; Interactive_type = make_type("Interactive", mod_type, Interactive_fields, 1); if (!Interactive_type) return 0; Expression_type = make_type("Expression", mod_type, Expression_fields, 1); if (!Expression_type) return 0; FunctionType_type = make_type("FunctionType", mod_type, FunctionType_fields, 2); if (!FunctionType_type) return 0; Suite_type = make_type("Suite", mod_type, Suite_fields, 1); if (!Suite_type) return 0; stmt_type = make_type("stmt", &AST_type, NULL, 0); if (!stmt_type) return 0; if (!add_attributes(stmt_type, stmt_attributes, 2)) return 0; FunctionDef_type = make_type("FunctionDef", stmt_type, FunctionDef_fields, 6); if (!FunctionDef_type) return 0; AsyncFunctionDef_type = make_type("AsyncFunctionDef", stmt_type, AsyncFunctionDef_fields, 6); if (!AsyncFunctionDef_type) return 0; ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 5); if (!ClassDef_type) return 0; Return_type = make_type("Return", stmt_type, Return_fields, 1); if (!Return_type) return 0; Delete_type = make_type("Delete", stmt_type, Delete_fields, 1); if (!Delete_type) return 0; Assign_type = make_type("Assign", stmt_type, Assign_fields, 3); if (!Assign_type) return 0; AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3); if (!AugAssign_type) return 0; AnnAssign_type = make_type("AnnAssign", stmt_type, AnnAssign_fields, 4); if (!AnnAssign_type) return 0; For_type = make_type("For", stmt_type, For_fields, 5); if (!For_type) return 0; AsyncFor_type = make_type("AsyncFor", stmt_type, AsyncFor_fields, 5); if (!AsyncFor_type) return 0; While_type = make_type("While", stmt_type, While_fields, 3); if (!While_type) return 0; If_type = make_type("If", stmt_type, If_fields, 3); if (!If_type) return 0; With_type = make_type("With", stmt_type, With_fields, 3); if (!With_type) return 0; AsyncWith_type = make_type("AsyncWith", stmt_type, AsyncWith_fields, 3); if (!AsyncWith_type) return 0; Raise_type = make_type("Raise", stmt_type, Raise_fields, 2); if (!Raise_type) return 0; Try_type = make_type("Try", stmt_type, Try_fields, 4); if (!Try_type) return 0; Assert_type = make_type("Assert", stmt_type, Assert_fields, 2); if (!Assert_type) return 0; Import_type = make_type("Import", stmt_type, Import_fields, 1); if (!Import_type) return 0; ImportFrom_type = make_type("ImportFrom", stmt_type, ImportFrom_fields, 3); if (!ImportFrom_type) return 0; Global_type = make_type("Global", stmt_type, Global_fields, 1); if (!Global_type) return 0; Nonlocal_type = make_type("Nonlocal", stmt_type, Nonlocal_fields, 1); if (!Nonlocal_type) return 0; Expr_type = make_type("Expr", stmt_type, Expr_fields, 1); if (!Expr_type) return 0; Pass_type = make_type("Pass", stmt_type, NULL, 0); if (!Pass_type) return 0; Break_type = make_type("Break", stmt_type, NULL, 0); if (!Break_type) return 0; Continue_type = make_type("Continue", stmt_type, NULL, 0); if (!Continue_type) return 0; expr_type = make_type("expr", &AST_type, NULL, 0); if (!expr_type) return 0; if (!add_attributes(expr_type, expr_attributes, 2)) return 0; BoolOp_type = make_type("BoolOp", expr_type, BoolOp_fields, 2); if (!BoolOp_type) return 0; BinOp_type = make_type("BinOp", expr_type, BinOp_fields, 3); if (!BinOp_type) return 0; UnaryOp_type = make_type("UnaryOp", expr_type, UnaryOp_fields, 2); if (!UnaryOp_type) return 0; Lambda_type = make_type("Lambda", expr_type, Lambda_fields, 2); if (!Lambda_type) return 0; IfExp_type = make_type("IfExp", expr_type, IfExp_fields, 3); if (!IfExp_type) return 0; Dict_type = make_type("Dict", expr_type, Dict_fields, 2); if (!Dict_type) return 0; Set_type = make_type("Set", expr_type, Set_fields, 1); if (!Set_type) return 0; ListComp_type = make_type("ListComp", expr_type, ListComp_fields, 2); if (!ListComp_type) return 0; SetComp_type = make_type("SetComp", expr_type, SetComp_fields, 2); if (!SetComp_type) return 0; DictComp_type = make_type("DictComp", expr_type, DictComp_fields, 3); if (!DictComp_type) return 0; GeneratorExp_type = make_type("GeneratorExp", expr_type, GeneratorExp_fields, 2); if (!GeneratorExp_type) return 0; Await_type = make_type("Await", expr_type, Await_fields, 1); if (!Await_type) return 0; Yield_type = make_type("Yield", expr_type, Yield_fields, 1); if (!Yield_type) return 0; YieldFrom_type = make_type("YieldFrom", expr_type, YieldFrom_fields, 1); if (!YieldFrom_type) return 0; Compare_type = make_type("Compare", expr_type, Compare_fields, 3); if (!Compare_type) return 0; Call_type = make_type("Call", expr_type, Call_fields, 3); if (!Call_type) return 0; Num_type = make_type("Num", expr_type, Num_fields, 1); if (!Num_type) return 0; Str_type = make_type("Str", expr_type, Str_fields, 1); if (!Str_type) return 0; FormattedValue_type = make_type("FormattedValue", expr_type, FormattedValue_fields, 3); if (!FormattedValue_type) return 0; JoinedStr_type = make_type("JoinedStr", expr_type, JoinedStr_fields, 1); if (!JoinedStr_type) return 0; Bytes_type = make_type("Bytes", expr_type, Bytes_fields, 1); if (!Bytes_type) return 0; NameConstant_type = make_type("NameConstant", expr_type, NameConstant_fields, 1); if (!NameConstant_type) return 0; Ellipsis_type = make_type("Ellipsis", expr_type, NULL, 0); if (!Ellipsis_type) return 0; Constant_type = make_type("Constant", expr_type, Constant_fields, 1); if (!Constant_type) return 0; Attribute_type = make_type("Attribute", expr_type, Attribute_fields, 3); if (!Attribute_type) return 0; Subscript_type = make_type("Subscript", expr_type, Subscript_fields, 3); if (!Subscript_type) return 0; Starred_type = make_type("Starred", expr_type, Starred_fields, 2); if (!Starred_type) return 0; Name_type = make_type("Name", expr_type, Name_fields, 2); if (!Name_type) return 0; List_type = make_type("List", expr_type, List_fields, 2); if (!List_type) return 0; Tuple_type = make_type("Tuple", expr_type, Tuple_fields, 2); if (!Tuple_type) return 0; expr_context_type = make_type("expr_context", &AST_type, NULL, 0); if (!expr_context_type) return 0; if (!add_attributes(expr_context_type, NULL, 0)) return 0; Load_type = make_type("Load", expr_context_type, NULL, 0); if (!Load_type) return 0; Load_singleton = PyType_GenericNew(Load_type, NULL, NULL); if (!Load_singleton) return 0; Store_type = make_type("Store", expr_context_type, NULL, 0); if (!Store_type) return 0; Store_singleton = PyType_GenericNew(Store_type, NULL, NULL); if (!Store_singleton) return 0; Del_type = make_type("Del", expr_context_type, NULL, 0); if (!Del_type) return 0; Del_singleton = PyType_GenericNew(Del_type, NULL, NULL); if (!Del_singleton) return 0; AugLoad_type = make_type("AugLoad", expr_context_type, NULL, 0); if (!AugLoad_type) return 0; AugLoad_singleton = PyType_GenericNew(AugLoad_type, NULL, NULL); if (!AugLoad_singleton) return 0; AugStore_type = make_type("AugStore", expr_context_type, NULL, 0); if (!AugStore_type) return 0; AugStore_singleton = PyType_GenericNew(AugStore_type, NULL, NULL); if (!AugStore_singleton) return 0; Param_type = make_type("Param", expr_context_type, NULL, 0); if (!Param_type) return 0; Param_singleton = PyType_GenericNew(Param_type, NULL, NULL); if (!Param_singleton) return 0; slice_type = make_type("slice", &AST_type, NULL, 0); if (!slice_type) return 0; if (!add_attributes(slice_type, NULL, 0)) return 0; Slice_type = make_type("Slice", slice_type, Slice_fields, 3); if (!Slice_type) return 0; ExtSlice_type = make_type("ExtSlice", slice_type, ExtSlice_fields, 1); if (!ExtSlice_type) return 0; Index_type = make_type("Index", slice_type, Index_fields, 1); if (!Index_type) return 0; boolop_type = make_type("boolop", &AST_type, NULL, 0); if (!boolop_type) return 0; if (!add_attributes(boolop_type, NULL, 0)) return 0; And_type = make_type("And", boolop_type, NULL, 0); if (!And_type) return 0; And_singleton = PyType_GenericNew(And_type, NULL, NULL); if (!And_singleton) return 0; Or_type = make_type("Or", boolop_type, NULL, 0); if (!Or_type) return 0; Or_singleton = PyType_GenericNew(Or_type, NULL, NULL); if (!Or_singleton) return 0; operator_type = make_type("operator", &AST_type, NULL, 0); if (!operator_type) return 0; if (!add_attributes(operator_type, NULL, 0)) return 0; Add_type = make_type("Add", operator_type, NULL, 0); if (!Add_type) return 0; Add_singleton = PyType_GenericNew(Add_type, NULL, NULL); if (!Add_singleton) return 0; Sub_type = make_type("Sub", operator_type, NULL, 0); if (!Sub_type) return 0; Sub_singleton = PyType_GenericNew(Sub_type, NULL, NULL); if (!Sub_singleton) return 0; Mult_type = make_type("Mult", operator_type, NULL, 0); if (!Mult_type) return 0; Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL); if (!Mult_singleton) return 0; MatMult_type = make_type("MatMult", operator_type, NULL, 0); if (!MatMult_type) return 0; MatMult_singleton = PyType_GenericNew(MatMult_type, NULL, NULL); if (!MatMult_singleton) return 0; Div_type = make_type("Div", operator_type, NULL, 0); if (!Div_type) return 0; Div_singleton = PyType_GenericNew(Div_type, NULL, NULL); if (!Div_singleton) return 0; Mod_type = make_type("Mod", operator_type, NULL, 0); if (!Mod_type) return 0; Mod_singleton = PyType_GenericNew(Mod_type, NULL, NULL); if (!Mod_singleton) return 0; Pow_type = make_type("Pow", operator_type, NULL, 0); if (!Pow_type) return 0; Pow_singleton = PyType_GenericNew(Pow_type, NULL, NULL); if (!Pow_singleton) return 0; LShift_type = make_type("LShift", operator_type, NULL, 0); if (!LShift_type) return 0; LShift_singleton = PyType_GenericNew(LShift_type, NULL, NULL); if (!LShift_singleton) return 0; RShift_type = make_type("RShift", operator_type, NULL, 0); if (!RShift_type) return 0; RShift_singleton = PyType_GenericNew(RShift_type, NULL, NULL); if (!RShift_singleton) return 0; BitOr_type = make_type("BitOr", operator_type, NULL, 0); if (!BitOr_type) return 0; BitOr_singleton = PyType_GenericNew(BitOr_type, NULL, NULL); if (!BitOr_singleton) return 0; BitXor_type = make_type("BitXor", operator_type, NULL, 0); if (!BitXor_type) return 0; BitXor_singleton = PyType_GenericNew(BitXor_type, NULL, NULL); if (!BitXor_singleton) return 0; BitAnd_type = make_type("BitAnd", operator_type, NULL, 0); if (!BitAnd_type) return 0; BitAnd_singleton = PyType_GenericNew(BitAnd_type, NULL, NULL); if (!BitAnd_singleton) return 0; FloorDiv_type = make_type("FloorDiv", operator_type, NULL, 0); if (!FloorDiv_type) return 0; FloorDiv_singleton = PyType_GenericNew(FloorDiv_type, NULL, NULL); if (!FloorDiv_singleton) return 0; unaryop_type = make_type("unaryop", &AST_type, NULL, 0); if (!unaryop_type) return 0; if (!add_attributes(unaryop_type, NULL, 0)) return 0; Invert_type = make_type("Invert", unaryop_type, NULL, 0); if (!Invert_type) return 0; Invert_singleton = PyType_GenericNew(Invert_type, NULL, NULL); if (!Invert_singleton) return 0; Not_type = make_type("Not", unaryop_type, NULL, 0); if (!Not_type) return 0; Not_singleton = PyType_GenericNew(Not_type, NULL, NULL); if (!Not_singleton) return 0; UAdd_type = make_type("UAdd", unaryop_type, NULL, 0); if (!UAdd_type) return 0; UAdd_singleton = PyType_GenericNew(UAdd_type, NULL, NULL); if (!UAdd_singleton) return 0; USub_type = make_type("USub", unaryop_type, NULL, 0); if (!USub_type) return 0; USub_singleton = PyType_GenericNew(USub_type, NULL, NULL); if (!USub_singleton) return 0; cmpop_type = make_type("cmpop", &AST_type, NULL, 0); if (!cmpop_type) return 0; if (!add_attributes(cmpop_type, NULL, 0)) return 0; Eq_type = make_type("Eq", cmpop_type, NULL, 0); if (!Eq_type) return 0; Eq_singleton = PyType_GenericNew(Eq_type, NULL, NULL); if (!Eq_singleton) return 0; NotEq_type = make_type("NotEq", cmpop_type, NULL, 0); if (!NotEq_type) return 0; NotEq_singleton = PyType_GenericNew(NotEq_type, NULL, NULL); if (!NotEq_singleton) return 0; Lt_type = make_type("Lt", cmpop_type, NULL, 0); if (!Lt_type) return 0; Lt_singleton = PyType_GenericNew(Lt_type, NULL, NULL); if (!Lt_singleton) return 0; LtE_type = make_type("LtE", cmpop_type, NULL, 0); if (!LtE_type) return 0; LtE_singleton = PyType_GenericNew(LtE_type, NULL, NULL); if (!LtE_singleton) return 0; Gt_type = make_type("Gt", cmpop_type, NULL, 0); if (!Gt_type) return 0; Gt_singleton = PyType_GenericNew(Gt_type, NULL, NULL); if (!Gt_singleton) return 0; GtE_type = make_type("GtE", cmpop_type, NULL, 0); if (!GtE_type) return 0; GtE_singleton = PyType_GenericNew(GtE_type, NULL, NULL); if (!GtE_singleton) return 0; Is_type = make_type("Is", cmpop_type, NULL, 0); if (!Is_type) return 0; Is_singleton = PyType_GenericNew(Is_type, NULL, NULL); if (!Is_singleton) return 0; IsNot_type = make_type("IsNot", cmpop_type, NULL, 0); if (!IsNot_type) return 0; IsNot_singleton = PyType_GenericNew(IsNot_type, NULL, NULL); if (!IsNot_singleton) return 0; In_type = make_type("In", cmpop_type, NULL, 0); if (!In_type) return 0; In_singleton = PyType_GenericNew(In_type, NULL, NULL); if (!In_singleton) return 0; NotIn_type = make_type("NotIn", cmpop_type, NULL, 0); if (!NotIn_type) return 0; NotIn_singleton = PyType_GenericNew(NotIn_type, NULL, NULL); if (!NotIn_singleton) return 0; comprehension_type = make_type("comprehension", &AST_type, comprehension_fields, 4); if (!comprehension_type) return 0; if (!add_attributes(comprehension_type, NULL, 0)) return 0; excepthandler_type = make_type("excepthandler", &AST_type, NULL, 0); if (!excepthandler_type) return 0; if (!add_attributes(excepthandler_type, excepthandler_attributes, 2)) return 0; ExceptHandler_type = make_type("ExceptHandler", excepthandler_type, ExceptHandler_fields, 3); if (!ExceptHandler_type) return 0; arguments_type = make_type("arguments", &AST_type, arguments_fields, 6); if (!arguments_type) return 0; if (!add_attributes(arguments_type, NULL, 0)) return 0; arg_type = make_type("arg", &AST_type, arg_fields, 3); if (!arg_type) return 0; if (!add_attributes(arg_type, arg_attributes, 2)) return 0; keyword_type = make_type("keyword", &AST_type, keyword_fields, 2); if (!keyword_type) return 0; if (!add_attributes(keyword_type, NULL, 0)) return 0; alias_type = make_type("alias", &AST_type, alias_fields, 2); if (!alias_type) return 0; if (!add_attributes(alias_type, NULL, 0)) return 0; withitem_type = make_type("withitem", &AST_type, withitem_fields, 2); if (!withitem_type) return 0; if (!add_attributes(withitem_type, NULL, 0)) return 0; type_ignore_type = make_type("type_ignore", &AST_type, NULL, 0); if (!type_ignore_type) return 0; if (!add_attributes(type_ignore_type, NULL, 0)) return 0; TypeIgnore_type = make_type("TypeIgnore", type_ignore_type, TypeIgnore_fields, 1); if (!TypeIgnore_type) return 0; initialized = 1; return 1; } static int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena); static int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena); static int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena); static int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena); static int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena); static int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena); static int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena); static int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena); static int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena); static int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena); static int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena); static int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena); static int obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena); static int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena); static int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena); static int obj2ast_withitem(PyObject* obj, withitem_ty* out, PyArena* arena); static int obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena* arena); mod_ty Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Module_kind; p->v.Module.body = body; p->v.Module.type_ignores = type_ignores; return p; } mod_ty Interactive(asdl_seq * body, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Interactive_kind; p->v.Interactive.body = body; return p; } mod_ty Expression(expr_ty body, PyArena *arena) { mod_ty p; if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for Expression"); return NULL; } p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Expression_kind; p->v.Expression.body = body; return p; } mod_ty FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena) { mod_ty p; if (!returns) { PyErr_SetString(PyExc_ValueError, "field returns is required for FunctionType"); return NULL; } p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = FunctionType_kind; p->v.FunctionType.argtypes = argtypes; p->v.FunctionType.returns = returns; return p; } mod_ty Suite(asdl_seq * body, PyArena *arena) { mod_ty p; p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Suite_kind; p->v.Suite.body = body; return p; } stmt_ty FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, expr_ty returns, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for FunctionDef"); return NULL; } if (!args) { PyErr_SetString(PyExc_ValueError, "field args is required for FunctionDef"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = FunctionDef_kind; p->v.FunctionDef.name = name; p->v.FunctionDef.args = args; p->v.FunctionDef.body = body; p->v.FunctionDef.decorator_list = decorator_list; p->v.FunctionDef.returns = returns; p->v.FunctionDef.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, expr_ty returns, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for AsyncFunctionDef"); return NULL; } if (!args) { PyErr_SetString(PyExc_ValueError, "field args is required for AsyncFunctionDef"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AsyncFunctionDef_kind; p->v.AsyncFunctionDef.name = name; p->v.AsyncFunctionDef.args = args; p->v.AsyncFunctionDef.body = body; p->v.AsyncFunctionDef.decorator_list = decorator_list; p->v.AsyncFunctionDef.returns = returns; p->v.AsyncFunctionDef.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq * body, asdl_seq * decorator_list, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for ClassDef"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ClassDef_kind; p->v.ClassDef.name = name; p->v.ClassDef.bases = bases; p->v.ClassDef.keywords = keywords; p->v.ClassDef.body = body; p->v.ClassDef.decorator_list = decorator_list; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Return(expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Return_kind; p->v.Return.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Delete(asdl_seq * targets, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Delete_kind; p->v.Delete.targets = targets; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Assign"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Assign_kind; p->v.Assign.targets = targets; p->v.Assign.value = value; p->v.Assign.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for AugAssign"); return NULL; } if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for AugAssign"); return NULL; } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for AugAssign"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AugAssign_kind; p->v.AugAssign.target = target; p->v.AugAssign.op = op; p->v.AugAssign.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for AnnAssign"); return NULL; } if (!annotation) { PyErr_SetString(PyExc_ValueError, "field annotation is required for AnnAssign"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AnnAssign_kind; p->v.AnnAssign.target = target; p->v.AnnAssign.annotation = annotation; p->v.AnnAssign.value = value; p->v.AnnAssign.simple = simple; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for For"); return NULL; } if (!iter) { PyErr_SetString(PyExc_ValueError, "field iter is required for For"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = For_kind; p->v.For.target = target; p->v.For.iter = iter; p->v.For.body = body; p->v.For.orelse = orelse; p->v.For.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for AsyncFor"); return NULL; } if (!iter) { PyErr_SetString(PyExc_ValueError, "field iter is required for AsyncFor"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AsyncFor_kind; p->v.AsyncFor.target = target; p->v.AsyncFor.iter = iter; p->v.AsyncFor.body = body; p->v.AsyncFor.orelse = orelse; p->v.AsyncFor.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for While"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = While_kind; p->v.While.test = test; p->v.While.body = body; p->v.While.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for If"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = If_kind; p->v.If.test = test; p->v.If.body = body; p->v.If.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = With_kind; p->v.With.items = items; p->v.With.body = body; p->v.With.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = AsyncWith_kind; p->v.AsyncWith.items = items; p->v.AsyncWith.body = body; p->v.AsyncWith.type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Raise_kind; p->v.Raise.exc = exc; p->v.Raise.cause = cause; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, asdl_seq * finalbody, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Try_kind; p->v.Try.body = body; p->v.Try.handlers = handlers; p->v.Try.orelse = orelse; p->v.Try.finalbody = finalbody; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for Assert"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Assert_kind; p->v.Assert.test = test; p->v.Assert.msg = msg; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Import(asdl_seq * names, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Import_kind; p->v.Import.names = names; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ImportFrom_kind; p->v.ImportFrom.module = module; p->v.ImportFrom.names = names; p->v.ImportFrom.level = level; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Global(asdl_seq * names, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Global_kind; p->v.Global.names = names; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Nonlocal(asdl_seq * names, int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Nonlocal_kind; p->v.Nonlocal.names = names; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Expr(expr_ty value, int lineno, int col_offset, PyArena *arena) { stmt_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Expr"); return NULL; } p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Expr_kind; p->v.Expr.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Pass(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Pass_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Break(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Break_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } stmt_ty Continue(int lineno, int col_offset, PyArena *arena) { stmt_ty p; p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Continue_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for BoolOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = BoolOp_kind; p->v.BoolOp.op = op; p->v.BoolOp.values = values; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!left) { PyErr_SetString(PyExc_ValueError, "field left is required for BinOp"); return NULL; } if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for BinOp"); return NULL; } if (!right) { PyErr_SetString(PyExc_ValueError, "field right is required for BinOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = BinOp_kind; p->v.BinOp.left = left; p->v.BinOp.op = op; p->v.BinOp.right = right; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!op) { PyErr_SetString(PyExc_ValueError, "field op is required for UnaryOp"); return NULL; } if (!operand) { PyErr_SetString(PyExc_ValueError, "field operand is required for UnaryOp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = UnaryOp_kind; p->v.UnaryOp.op = op; p->v.UnaryOp.operand = operand; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!args) { PyErr_SetString(PyExc_ValueError, "field args is required for Lambda"); return NULL; } if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for Lambda"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Lambda_kind; p->v.Lambda.args = args; p->v.Lambda.body = body; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!test) { PyErr_SetString(PyExc_ValueError, "field test is required for IfExp"); return NULL; } if (!body) { PyErr_SetString(PyExc_ValueError, "field body is required for IfExp"); return NULL; } if (!orelse) { PyErr_SetString(PyExc_ValueError, "field orelse is required for IfExp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = IfExp_kind; p->v.IfExp.test = test; p->v.IfExp.body = body; p->v.IfExp.orelse = orelse; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Dict_kind; p->v.Dict.keys = keys; p->v.Dict.values = values; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Set_kind; p->v.Set.elts = elts; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for ListComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ListComp_kind; p->v.ListComp.elt = elt; p->v.ListComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for SetComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = SetComp_kind; p->v.SetComp.elt = elt; p->v.SetComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!key) { PyErr_SetString(PyExc_ValueError, "field key is required for DictComp"); return NULL; } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for DictComp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = DictComp_kind; p->v.DictComp.key = key; p->v.DictComp.value = value; p->v.DictComp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!elt) { PyErr_SetString(PyExc_ValueError, "field elt is required for GeneratorExp"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = GeneratorExp_kind; p->v.GeneratorExp.elt = elt; p->v.GeneratorExp.generators = generators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Await(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Await"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Await_kind; p->v.Await.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Yield(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Yield_kind; p->v.Yield.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty YieldFrom(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for YieldFrom"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = YieldFrom_kind; p->v.YieldFrom.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!left) { PyErr_SetString(PyExc_ValueError, "field left is required for Compare"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Compare_kind; p->v.Compare.left = left; p->v.Compare.ops = ops; p->v.Compare.comparators = comparators; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!func) { PyErr_SetString(PyExc_ValueError, "field func is required for Call"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Call_kind; p->v.Call.func = func; p->v.Call.args = args; p->v.Call.keywords = keywords; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Num(object n, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!n) { PyErr_SetString(PyExc_ValueError, "field n is required for Num"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Num_kind; p->v.Num.n = n; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Str(string s, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!s) { PyErr_SetString(PyExc_ValueError, "field s is required for Str"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Str_kind; p->v.Str.s = s; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for FormattedValue"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = FormattedValue_kind; p->v.FormattedValue.value = value; p->v.FormattedValue.conversion = conversion; p->v.FormattedValue.format_spec = format_spec; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty JoinedStr(asdl_seq * values, int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = JoinedStr_kind; p->v.JoinedStr.values = values; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Bytes(bytes s, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!s) { PyErr_SetString(PyExc_ValueError, "field s is required for Bytes"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Bytes_kind; p->v.Bytes.s = s; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty NameConstant(singleton value, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for NameConstant"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = NameConstant_kind; p->v.NameConstant.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Ellipsis(int lineno, int col_offset, PyArena *arena) { expr_ty p; p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Ellipsis_kind; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Constant(constant value, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Constant"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Constant_kind; p->v.Constant.value = value; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Attribute"); return NULL; } if (!attr) { PyErr_SetString(PyExc_ValueError, "field attr is required for Attribute"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Attribute"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Attribute_kind; p->v.Attribute.value = value; p->v.Attribute.attr = attr; p->v.Attribute.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Subscript"); return NULL; } if (!slice) { PyErr_SetString(PyExc_ValueError, "field slice is required for Subscript"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Subscript"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Subscript_kind; p->v.Subscript.value = value; p->v.Subscript.slice = slice; p->v.Subscript.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Starred"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Starred"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Starred_kind; p->v.Starred.value = value; p->v.Starred.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!id) { PyErr_SetString(PyExc_ValueError, "field id is required for Name"); return NULL; } if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Name"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Name_kind; p->v.Name.id = id; p->v.Name.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for List"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = List_kind; p->v.List.elts = elts; p->v.List.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } expr_ty Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, PyArena *arena) { expr_ty p; if (!ctx) { PyErr_SetString(PyExc_ValueError, "field ctx is required for Tuple"); return NULL; } p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Tuple_kind; p->v.Tuple.elts = elts; p->v.Tuple.ctx = ctx; p->lineno = lineno; p->col_offset = col_offset; return p; } slice_ty Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena) { slice_ty p; p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Slice_kind; p->v.Slice.lower = lower; p->v.Slice.upper = upper; p->v.Slice.step = step; return p; } slice_ty ExtSlice(asdl_seq * dims, PyArena *arena) { slice_ty p; p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ExtSlice_kind; p->v.ExtSlice.dims = dims; return p; } slice_ty Index(expr_ty value, PyArena *arena) { slice_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for Index"); return NULL; } p = (slice_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = Index_kind; p->v.Index.value = value; return p; } comprehension_ty comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, int is_async, PyArena *arena) { comprehension_ty p; if (!target) { PyErr_SetString(PyExc_ValueError, "field target is required for comprehension"); return NULL; } if (!iter) { PyErr_SetString(PyExc_ValueError, "field iter is required for comprehension"); return NULL; } p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->target = target; p->iter = iter; p->ifs = ifs; p->is_async = is_async; return p; } excepthandler_ty ExceptHandler(expr_ty type, identifier name, asdl_seq * body, int lineno, int col_offset, PyArena *arena) { excepthandler_ty p; p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = ExceptHandler_kind; p->v.ExceptHandler.type = type; p->v.ExceptHandler.name = name; p->v.ExceptHandler.body = body; p->lineno = lineno; p->col_offset = col_offset; return p; } arguments_ty arguments(asdl_seq * args, arg_ty vararg, asdl_seq * kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, asdl_seq * defaults, PyArena *arena) { arguments_ty p; p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->args = args; p->vararg = vararg; p->kwonlyargs = kwonlyargs; p->kw_defaults = kw_defaults; p->kwarg = kwarg; p->defaults = defaults; return p; } arg_ty arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int col_offset, PyArena *arena) { arg_ty p; if (!arg) { PyErr_SetString(PyExc_ValueError, "field arg is required for arg"); return NULL; } p = (arg_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->arg = arg; p->annotation = annotation; p->type_comment = type_comment; p->lineno = lineno; p->col_offset = col_offset; return p; } keyword_ty keyword(identifier arg, expr_ty value, PyArena *arena) { keyword_ty p; if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for keyword"); return NULL; } p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->arg = arg; p->value = value; return p; } alias_ty alias(identifier name, identifier asname, PyArena *arena) { alias_ty p; if (!name) { PyErr_SetString(PyExc_ValueError, "field name is required for alias"); return NULL; } p = (alias_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->name = name; p->asname = asname; return p; } withitem_ty withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena) { withitem_ty p; if (!context_expr) { PyErr_SetString(PyExc_ValueError, "field context_expr is required for withitem"); return NULL; } p = (withitem_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->context_expr = context_expr; p->optional_vars = optional_vars; return p; } type_ignore_ty TypeIgnore(int lineno, PyArena *arena) { type_ignore_ty p; p = (type_ignore_ty)PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; p->kind = TypeIgnore_kind; p->v.TypeIgnore.lineno = lineno; return p; } PyObject* ast2obj_mod(void* _o) { mod_ty o = (mod_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case Module_kind: result = PyType_GenericNew(Module_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Module.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Module.type_ignores, ast2obj_type_ignore); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_ignores, value) == -1) goto failed; Py_DECREF(value); break; case Interactive_kind: result = PyType_GenericNew(Interactive_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Interactive.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); break; case Expression_kind: result = PyType_GenericNew(Expression_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Expression.body); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); break; case FunctionType_kind: result = PyType_GenericNew(FunctionType_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.FunctionType.argtypes, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_argtypes, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.FunctionType.returns); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_returns, value) == -1) goto failed; Py_DECREF(value); break; case Suite_kind: result = PyType_GenericNew(Suite_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Suite.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_stmt(void* _o) { stmt_ty o = (stmt_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case FunctionDef_kind: result = PyType_GenericNew(FunctionDef_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.FunctionDef.name); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_arguments(o->v.FunctionDef.args); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.FunctionDef.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.FunctionDef.decorator_list, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_decorator_list, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.FunctionDef.returns); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_returns, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.FunctionDef.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case AsyncFunctionDef_kind: result = PyType_GenericNew(AsyncFunctionDef_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.AsyncFunctionDef.name); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_arguments(o->v.AsyncFunctionDef.args); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.AsyncFunctionDef.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.AsyncFunctionDef.decorator_list, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_decorator_list, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AsyncFunctionDef.returns); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_returns, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.AsyncFunctionDef.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case ClassDef_kind: result = PyType_GenericNew(ClassDef_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.ClassDef.name); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.bases, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_bases, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.keywords, ast2obj_keyword); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_keywords, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.decorator_list, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_decorator_list, value) == -1) goto failed; Py_DECREF(value); break; case Return_kind: result = PyType_GenericNew(Return_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Return.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Delete_kind: result = PyType_GenericNew(Delete_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Delete.targets, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_targets, value) == -1) goto failed; Py_DECREF(value); break; case Assign_kind: result = PyType_GenericNew(Assign_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Assign.targets, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_targets, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Assign.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.Assign.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case AugAssign_kind: result = PyType_GenericNew(AugAssign_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.AugAssign.target); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_operator(o->v.AugAssign.op); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_op, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AugAssign.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case AnnAssign_kind: result = PyType_GenericNew(AnnAssign_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.AnnAssign.target); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AnnAssign.annotation); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_annotation, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AnnAssign.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->v.AnnAssign.simple); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_simple, value) == -1) goto failed; Py_DECREF(value); break; case For_kind: result = PyType_GenericNew(For_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.For.target); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.For.iter); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_iter, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.For.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.For.orelse, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.For.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case AsyncFor_kind: result = PyType_GenericNew(AsyncFor_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.AsyncFor.target); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.AsyncFor.iter); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_iter, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.AsyncFor.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.AsyncFor.orelse, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.AsyncFor.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case While_kind: result = PyType_GenericNew(While_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.While.test); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_test, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.While.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.While.orelse, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); break; case If_kind: result = PyType_GenericNew(If_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.If.test); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_test, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.If.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.If.orelse, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); break; case With_kind: result = PyType_GenericNew(With_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.With.items, ast2obj_withitem); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_items, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.With.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.With.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case AsyncWith_kind: result = PyType_GenericNew(AsyncWith_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.AsyncWith.items, ast2obj_withitem); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_items, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.AsyncWith.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->v.AsyncWith.type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); break; case Raise_kind: result = PyType_GenericNew(Raise_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Raise.exc); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_exc, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Raise.cause); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_cause, value) == -1) goto failed; Py_DECREF(value); break; case Try_kind: result = PyType_GenericNew(Try_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Try.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Try.handlers, ast2obj_excepthandler); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_handlers, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Try.orelse, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Try.finalbody, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_finalbody, value) == -1) goto failed; Py_DECREF(value); break; case Assert_kind: result = PyType_GenericNew(Assert_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Assert.test); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_test, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Assert.msg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_msg, value) == -1) goto failed; Py_DECREF(value); break; case Import_kind: result = PyType_GenericNew(Import_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Import.names, ast2obj_alias); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_names, value) == -1) goto failed; Py_DECREF(value); break; case ImportFrom_kind: result = PyType_GenericNew(ImportFrom_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.ImportFrom.module); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_module, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ImportFrom.names, ast2obj_alias); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_names, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->v.ImportFrom.level); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_level, value) == -1) goto failed; Py_DECREF(value); break; case Global_kind: result = PyType_GenericNew(Global_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Global.names, ast2obj_identifier); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_names, value) == -1) goto failed; Py_DECREF(value); break; case Nonlocal_kind: result = PyType_GenericNew(Nonlocal_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Nonlocal.names, ast2obj_identifier); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_names, value) == -1) goto failed; Py_DECREF(value); break; case Expr_kind: result = PyType_GenericNew(Expr_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Expr.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Pass_kind: result = PyType_GenericNew(Pass_type, NULL, NULL); if (!result) goto failed; break; case Break_kind: result = PyType_GenericNew(Break_type, NULL, NULL); if (!result) goto failed; break; case Continue_kind: result = PyType_GenericNew(Continue_type, NULL, NULL); if (!result) goto failed; break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lineno, value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_col_offset, value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_expr(void* _o) { expr_ty o = (expr_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case BoolOp_kind: result = PyType_GenericNew(BoolOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_boolop(o->v.BoolOp.op); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_op, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.BoolOp.values, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_values, value) == -1) goto failed; Py_DECREF(value); break; case BinOp_kind: result = PyType_GenericNew(BinOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.BinOp.left); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_left, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_operator(o->v.BinOp.op); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_op, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.BinOp.right); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_right, value) == -1) goto failed; Py_DECREF(value); break; case UnaryOp_kind: result = PyType_GenericNew(UnaryOp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_unaryop(o->v.UnaryOp.op); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_op, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.UnaryOp.operand); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_operand, value) == -1) goto failed; Py_DECREF(value); break; case Lambda_kind: result = PyType_GenericNew(Lambda_type, NULL, NULL); if (!result) goto failed; value = ast2obj_arguments(o->v.Lambda.args); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Lambda.body); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); break; case IfExp_kind: result = PyType_GenericNew(IfExp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.IfExp.test); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_test, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.IfExp.body); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.IfExp.orelse); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) goto failed; Py_DECREF(value); break; case Dict_kind: result = PyType_GenericNew(Dict_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Dict.keys, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_keys, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Dict.values, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_values, value) == -1) goto failed; Py_DECREF(value); break; case Set_kind: result = PyType_GenericNew(Set_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Set.elts, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elts, value) == -1) goto failed; Py_DECREF(value); break; case ListComp_kind: result = PyType_GenericNew(ListComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.ListComp.elt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elt, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ListComp.generators, ast2obj_comprehension); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_generators, value) == -1) goto failed; Py_DECREF(value); break; case SetComp_kind: result = PyType_GenericNew(SetComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.SetComp.elt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elt, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.SetComp.generators, ast2obj_comprehension); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_generators, value) == -1) goto failed; Py_DECREF(value); break; case DictComp_kind: result = PyType_GenericNew(DictComp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.DictComp.key); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_key, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.DictComp.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.DictComp.generators, ast2obj_comprehension); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_generators, value) == -1) goto failed; Py_DECREF(value); break; case GeneratorExp_kind: result = PyType_GenericNew(GeneratorExp_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.GeneratorExp.elt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elt, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.GeneratorExp.generators, ast2obj_comprehension); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_generators, value) == -1) goto failed; Py_DECREF(value); break; case Await_kind: result = PyType_GenericNew(Await_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Await.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Yield_kind: result = PyType_GenericNew(Yield_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Yield.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case YieldFrom_kind: result = PyType_GenericNew(YieldFrom_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.YieldFrom.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Compare_kind: result = PyType_GenericNew(Compare_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Compare.left); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_left, value) == -1) goto failed; Py_DECREF(value); { Py_ssize_t i, n = asdl_seq_LEN(o->v.Compare.ops); value = PyList_New(n); if (!value) goto failed; for(i = 0; i < n; i++) PyList_SET_ITEM(value, i, ast2obj_cmpop((cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i))); } if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ops, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Compare.comparators, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_comparators, value) == -1) goto failed; Py_DECREF(value); break; case Call_kind: result = PyType_GenericNew(Call_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Call.func); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_func, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Call.args, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.Call.keywords, ast2obj_keyword); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_keywords, value) == -1) goto failed; Py_DECREF(value); break; case Num_kind: result = PyType_GenericNew(Num_type, NULL, NULL); if (!result) goto failed; value = ast2obj_object(o->v.Num.n); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_n, value) == -1) goto failed; Py_DECREF(value); break; case Str_kind: result = PyType_GenericNew(Str_type, NULL, NULL); if (!result) goto failed; value = ast2obj_string(o->v.Str.s); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_s, value) == -1) goto failed; Py_DECREF(value); break; case FormattedValue_kind: result = PyType_GenericNew(FormattedValue_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.FormattedValue.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->v.FormattedValue.conversion); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_conversion, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.FormattedValue.format_spec); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_format_spec, value) == -1) goto failed; Py_DECREF(value); break; case JoinedStr_kind: result = PyType_GenericNew(JoinedStr_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.JoinedStr.values, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_values, value) == -1) goto failed; Py_DECREF(value); break; case Bytes_kind: result = PyType_GenericNew(Bytes_type, NULL, NULL); if (!result) goto failed; value = ast2obj_bytes(o->v.Bytes.s); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_s, value) == -1) goto failed; Py_DECREF(value); break; case NameConstant_kind: result = PyType_GenericNew(NameConstant_type, NULL, NULL); if (!result) goto failed; value = ast2obj_singleton(o->v.NameConstant.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Ellipsis_kind: result = PyType_GenericNew(Ellipsis_type, NULL, NULL); if (!result) goto failed; break; case Constant_kind: result = PyType_GenericNew(Constant_type, NULL, NULL); if (!result) goto failed; value = ast2obj_constant(o->v.Constant.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; case Attribute_kind: result = PyType_GenericNew(Attribute_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Attribute.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->v.Attribute.attr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_attr, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Attribute.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; case Subscript_kind: result = PyType_GenericNew(Subscript_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Subscript.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_slice(o->v.Subscript.slice); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_slice, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Subscript.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; case Starred_kind: result = PyType_GenericNew(Starred_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Starred.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Starred.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; case Name_kind: result = PyType_GenericNew(Name_type, NULL, NULL); if (!result) goto failed; value = ast2obj_identifier(o->v.Name.id); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_id, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Name.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; case List_kind: result = PyType_GenericNew(List_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.List.elts, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elts, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.List.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; case Tuple_kind: result = PyType_GenericNew(Tuple_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.Tuple.elts, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_elts, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr_context(o->v.Tuple.ctx); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ctx, value) == -1) goto failed; Py_DECREF(value); break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lineno, value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_col_offset, value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_expr_context(expr_context_ty o) { switch(o) { case Load: Py_INCREF(Load_singleton); return Load_singleton; case Store: Py_INCREF(Store_singleton); return Store_singleton; case Del: Py_INCREF(Del_singleton); return Del_singleton; case AugLoad: Py_INCREF(AugLoad_singleton); return AugLoad_singleton; case AugStore: Py_INCREF(AugStore_singleton); return AugStore_singleton; case Param: Py_INCREF(Param_singleton); return Param_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown expr_context found"); return NULL; } } PyObject* ast2obj_slice(void* _o) { slice_ty o = (slice_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case Slice_kind: result = PyType_GenericNew(Slice_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Slice.lower); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lower, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Slice.upper); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_upper, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->v.Slice.step); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_step, value) == -1) goto failed; Py_DECREF(value); break; case ExtSlice_kind: result = PyType_GenericNew(ExtSlice_type, NULL, NULL); if (!result) goto failed; value = ast2obj_list(o->v.ExtSlice.dims, ast2obj_slice); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_dims, value) == -1) goto failed; Py_DECREF(value); break; case Index_kind: result = PyType_GenericNew(Index_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.Index.value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_boolop(boolop_ty o) { switch(o) { case And: Py_INCREF(And_singleton); return And_singleton; case Or: Py_INCREF(Or_singleton); return Or_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown boolop found"); return NULL; } } PyObject* ast2obj_operator(operator_ty o) { switch(o) { case Add: Py_INCREF(Add_singleton); return Add_singleton; case Sub: Py_INCREF(Sub_singleton); return Sub_singleton; case Mult: Py_INCREF(Mult_singleton); return Mult_singleton; case MatMult: Py_INCREF(MatMult_singleton); return MatMult_singleton; case Div: Py_INCREF(Div_singleton); return Div_singleton; case Mod: Py_INCREF(Mod_singleton); return Mod_singleton; case Pow: Py_INCREF(Pow_singleton); return Pow_singleton; case LShift: Py_INCREF(LShift_singleton); return LShift_singleton; case RShift: Py_INCREF(RShift_singleton); return RShift_singleton; case BitOr: Py_INCREF(BitOr_singleton); return BitOr_singleton; case BitXor: Py_INCREF(BitXor_singleton); return BitXor_singleton; case BitAnd: Py_INCREF(BitAnd_singleton); return BitAnd_singleton; case FloorDiv: Py_INCREF(FloorDiv_singleton); return FloorDiv_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown operator found"); return NULL; } } PyObject* ast2obj_unaryop(unaryop_ty o) { switch(o) { case Invert: Py_INCREF(Invert_singleton); return Invert_singleton; case Not: Py_INCREF(Not_singleton); return Not_singleton; case UAdd: Py_INCREF(UAdd_singleton); return UAdd_singleton; case USub: Py_INCREF(USub_singleton); return USub_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown unaryop found"); return NULL; } } PyObject* ast2obj_cmpop(cmpop_ty o) { switch(o) { case Eq: Py_INCREF(Eq_singleton); return Eq_singleton; case NotEq: Py_INCREF(NotEq_singleton); return NotEq_singleton; case Lt: Py_INCREF(Lt_singleton); return Lt_singleton; case LtE: Py_INCREF(LtE_singleton); return LtE_singleton; case Gt: Py_INCREF(Gt_singleton); return Gt_singleton; case GtE: Py_INCREF(GtE_singleton); return GtE_singleton; case Is: Py_INCREF(Is_singleton); return Is_singleton; case IsNot: Py_INCREF(IsNot_singleton); return IsNot_singleton; case In: Py_INCREF(In_singleton); return In_singleton; case NotIn: Py_INCREF(NotIn_singleton); return NotIn_singleton; default: /* should never happen, but just in case ... */ PyErr_Format(PyExc_SystemError, "unknown cmpop found"); return NULL; } } PyObject* ast2obj_comprehension(void* _o) { comprehension_ty o = (comprehension_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(comprehension_type, NULL, NULL); if (!result) return NULL; value = ast2obj_expr(o->target); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->iter); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_iter, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->ifs, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_ifs, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->is_async); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_is_async, value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_excepthandler(void* _o) { excepthandler_ty o = (excepthandler_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case ExceptHandler_kind: result = PyType_GenericNew(ExceptHandler_type, NULL, NULL); if (!result) goto failed; value = ast2obj_expr(o->v.ExceptHandler.type); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->v.ExceptHandler.name); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) goto failed; Py_DECREF(value); break; } value = ast2obj_int(o->lineno); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lineno, value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_col_offset, value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_arguments(void* _o) { arguments_ty o = (arguments_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(arguments_type, NULL, NULL); if (!result) return NULL; value = ast2obj_list(o->args, ast2obj_arg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_arg(o->vararg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_vararg, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->kwonlyargs, ast2obj_arg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_kwonlyargs, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->kw_defaults, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_kw_defaults, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_arg(o->kwarg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_kwarg, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_list(o->defaults, ast2obj_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_defaults, value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_arg(void* _o) { arg_ty o = (arg_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(arg_type, NULL, NULL); if (!result) return NULL; value = ast2obj_identifier(o->arg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_arg, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->annotation); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_annotation, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_string(o->type_comment); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_type_comment, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_int(o->lineno); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lineno, value) < 0) goto failed; Py_DECREF(value); value = ast2obj_int(o->col_offset); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_col_offset, value) < 0) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_keyword(void* _o) { keyword_ty o = (keyword_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(keyword_type, NULL, NULL); if (!result) return NULL; value = ast2obj_identifier(o->arg); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_arg, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->value); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_alias(void* _o) { alias_ty o = (alias_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(alias_type, NULL, NULL); if (!result) return NULL; value = ast2obj_identifier(o->name); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_identifier(o->asname); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_asname, value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_withitem(void* _o) { withitem_ty o = (withitem_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } result = PyType_GenericNew(withitem_type, NULL, NULL); if (!result) return NULL; value = ast2obj_expr(o->context_expr); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_context_expr, value) == -1) goto failed; Py_DECREF(value); value = ast2obj_expr(o->optional_vars); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_optional_vars, value) == -1) goto failed; Py_DECREF(value); return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } PyObject* ast2obj_type_ignore(void* _o) { type_ignore_ty o = (type_ignore_ty)_o; PyObject *result = NULL, *value = NULL; if (!o) { Py_INCREF(Py_None); return Py_None; } switch (o->kind) { case TypeIgnore_kind: result = PyType_GenericNew(TypeIgnore_type, NULL, NULL); if (!result) goto failed; value = ast2obj_int(o->v.TypeIgnore.lineno); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_lineno, value) == -1) goto failed; Py_DECREF(value); break; } return result; failed: Py_XDECREF(value); Py_XDECREF(result); return NULL; } int obj2ast_mod(PyObject* obj, mod_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Module_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; asdl_seq* type_ignores; if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Module"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_type_ignores)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_type_ignores); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); type_ignores = _Ta3_asdl_seq_new(len, arena); if (type_ignores == NULL) goto failed; for (i = 0; i < len; i++) { type_ignore_ty value; res = obj2ast_type_ignore(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration"); goto failed; } asdl_seq_SET(type_ignores, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module"); return 1; } *out = Module(body, type_ignores, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Interactive_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Interactive"); return 1; } *out = Interactive(body, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Expression_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty body; if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Expression"); return 1; } *out = Expression(body, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionType_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* argtypes; expr_ty returns; if (_PyObject_HasAttrId(obj, &PyId_argtypes)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_argtypes); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); argtypes = _Ta3_asdl_seq_new(len, arena); if (argtypes == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration"); goto failed; } asdl_seq_SET(argtypes, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_returns)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_returns); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &returns, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType"); return 1; } *out = FunctionType(argtypes, returns, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Suite_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Suite field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Suite field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Suite"); return 1; } *out = Suite(body, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } int obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (_PyObject_HasAttrId(obj, &PyId_lineno)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lineno); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from stmt"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_col_offset)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_col_offset); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from stmt"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)FunctionDef_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier name; arguments_ty args; asdl_seq* body; asdl_seq* decorator_list; expr_ty returns; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_name)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_name); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from FunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_args)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_args); if (tmp == NULL) goto failed; res = obj2ast_arguments(tmp, &args, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from FunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from FunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_decorator_list)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_decorator_list); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); decorator_list = _Ta3_asdl_seq_new(len, arena); if (decorator_list == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration"); goto failed; } asdl_seq_SET(decorator_list, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from FunctionDef"); return 1; } if (exists_not_none(obj, &PyId_returns)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_returns); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &returns, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { returns = NULL; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = FunctionDef(name, args, body, decorator_list, returns, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncFunctionDef_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier name; arguments_ty args; asdl_seq* body; asdl_seq* decorator_list; expr_ty returns; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_name)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_name); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from AsyncFunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_args)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_args); if (tmp == NULL) goto failed; res = obj2ast_arguments(tmp, &args, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from AsyncFunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFunctionDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_decorator_list)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_decorator_list); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); decorator_list = _Ta3_asdl_seq_new(len, arena); if (decorator_list == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"decorator_list\" changed size during iteration"); goto failed; } asdl_seq_SET(decorator_list, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from AsyncFunctionDef"); return 1; } if (exists_not_none(obj, &PyId_returns)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_returns); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &returns, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { returns = NULL; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ClassDef_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier name; asdl_seq* bases; asdl_seq* keywords; asdl_seq* body; asdl_seq* decorator_list; if (_PyObject_HasAttrId(obj, &PyId_name)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_name); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from ClassDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_bases)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_bases); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); bases = _Ta3_asdl_seq_new(len, arena); if (bases == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration"); goto failed; } asdl_seq_SET(bases, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"bases\" missing from ClassDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_keywords)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_keywords); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); keywords = _Ta3_asdl_seq_new(len, arena); if (keywords == NULL) goto failed; for (i = 0; i < len; i++) { keyword_ty value; res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"keywords\" changed size during iteration"); goto failed; } asdl_seq_SET(keywords, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from ClassDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ClassDef"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_decorator_list)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_decorator_list); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); decorator_list = _Ta3_asdl_seq_new(len, arena); if (decorator_list == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration"); goto failed; } asdl_seq_SET(decorator_list, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef"); return 1; } *out = ClassDef(name, bases, keywords, body, decorator_list, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Return_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (exists_not_none(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { value = NULL; } *out = Return(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Delete_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* targets; if (_PyObject_HasAttrId(obj, &PyId_targets)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_targets); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); targets = _Ta3_asdl_seq_new(len, arena); if (targets == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration"); goto failed; } asdl_seq_SET(targets, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Delete"); return 1; } *out = Delete(targets, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Assign_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* targets; expr_ty value; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_targets)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_targets); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); targets = _Ta3_asdl_seq_new(len, arena); if (targets == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration"); goto failed; } asdl_seq_SET(targets, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"targets\" missing from Assign"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Assign"); return 1; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = Assign(targets, value, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AugAssign_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; operator_ty op; expr_ty value; if (_PyObject_HasAttrId(obj, &PyId_target)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_target); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AugAssign"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_op)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_op); if (tmp == NULL) goto failed; res = obj2ast_operator(tmp, &op, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from AugAssign"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from AugAssign"); return 1; } *out = AugAssign(target, op, value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AnnAssign_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; expr_ty annotation; expr_ty value; int simple; if (_PyObject_HasAttrId(obj, &PyId_target)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_target); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AnnAssign"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_annotation)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_annotation); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &annotation, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"annotation\" missing from AnnAssign"); return 1; } if (exists_not_none(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { value = NULL; } if (_PyObject_HasAttrId(obj, &PyId_simple)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_simple); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &simple, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"simple\" missing from AnnAssign"); return 1; } *out = AnnAssign(target, annotation, value, simple, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)For_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; expr_ty iter; asdl_seq* body; asdl_seq* orelse; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_target)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_target); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from For"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_iter)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_iter); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &iter, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from For"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from For"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = _Ta3_asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration"); goto failed; } asdl_seq_SET(orelse, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from For"); return 1; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = For(target, iter, body, orelse, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncFor_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty target; expr_ty iter; asdl_seq* body; asdl_seq* orelse; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_target)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_target); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AsyncFor"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_iter)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_iter); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &iter, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from AsyncFor"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFor"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = _Ta3_asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"orelse\" changed size during iteration"); goto failed; } asdl_seq_SET(orelse, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from AsyncFor"); return 1; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = AsyncFor(target, iter, body, orelse, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)While_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; asdl_seq* body; asdl_seq* orelse; if (_PyObject_HasAttrId(obj, &PyId_test)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_test); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from While"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from While"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = _Ta3_asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration"); goto failed; } asdl_seq_SET(orelse, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from While"); return 1; } *out = While(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)If_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; asdl_seq* body; asdl_seq* orelse; if (_PyObject_HasAttrId(obj, &PyId_test)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_test); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from If"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from If"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = _Ta3_asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration"); goto failed; } asdl_seq_SET(orelse, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from If"); return 1; } *out = If(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)With_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* items; asdl_seq* body; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_items)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_items); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); items = _Ta3_asdl_seq_new(len, arena); if (items == NULL) goto failed; for (i = 0; i < len; i++) { withitem_ty value; res = obj2ast_withitem(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "With field \"items\" changed size during iteration"); goto failed; } asdl_seq_SET(items, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from With"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from With"); return 1; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = With(items, body, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncWith_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* items; asdl_seq* body; string type_comment; if (_PyObject_HasAttrId(obj, &PyId_items)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_items); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); items = _Ta3_asdl_seq_new(len, arena); if (items == NULL) goto failed; for (i = 0; i < len; i++) { withitem_ty value; res = obj2ast_withitem(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"items\" changed size during iteration"); goto failed; } asdl_seq_SET(items, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from AsyncWith"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncWith"); return 1; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } *out = AsyncWith(items, body, type_comment, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Raise_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty exc; expr_ty cause; if (exists_not_none(obj, &PyId_exc)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_exc); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &exc, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { exc = NULL; } if (exists_not_none(obj, &PyId_cause)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_cause); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &cause, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { cause = NULL; } *out = Raise(exc, cause, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Try_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* body; asdl_seq* handlers; asdl_seq* orelse; asdl_seq* finalbody; if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Try field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Try"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_handlers)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_handlers); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); handlers = _Ta3_asdl_seq_new(len, arena); if (handlers == NULL) goto failed; for (i = 0; i < len; i++) { excepthandler_ty value; res = obj2ast_excepthandler(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Try field \"handlers\" changed size during iteration"); goto failed; } asdl_seq_SET(handlers, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"handlers\" missing from Try"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); orelse = _Ta3_asdl_seq_new(len, arena); if (orelse == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Try field \"orelse\" changed size during iteration"); goto failed; } asdl_seq_SET(orelse, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from Try"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_finalbody)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_finalbody); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); finalbody = _Ta3_asdl_seq_new(len, arena); if (finalbody == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Try field \"finalbody\" changed size during iteration"); goto failed; } asdl_seq_SET(finalbody, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"finalbody\" missing from Try"); return 1; } *out = Try(body, handlers, orelse, finalbody, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Assert_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; expr_ty msg; if (_PyObject_HasAttrId(obj, &PyId_test)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_test); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from Assert"); return 1; } if (exists_not_none(obj, &PyId_msg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_msg); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &msg, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { msg = NULL; } *out = Assert(test, msg, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Import_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* names; if (_PyObject_HasAttrId(obj, &PyId_names)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_names); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = _Ta3_asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { alias_ty value; res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration"); goto failed; } asdl_seq_SET(names, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Import"); return 1; } *out = Import(names, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ImportFrom_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier module; asdl_seq* names; int level; if (exists_not_none(obj, &PyId_module)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_module); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &module, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { module = NULL; } if (_PyObject_HasAttrId(obj, &PyId_names)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_names); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = _Ta3_asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { alias_ty value; res = obj2ast_alias(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration"); goto failed; } asdl_seq_SET(names, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from ImportFrom"); return 1; } if (exists_not_none(obj, &PyId_level)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_level); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &level, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { level = 0; } *out = ImportFrom(module, names, level, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Global_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* names; if (_PyObject_HasAttrId(obj, &PyId_names)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_names); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = _Ta3_asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { identifier value; res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration"); goto failed; } asdl_seq_SET(names, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Global"); return 1; } *out = Global(names, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Nonlocal_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* names; if (_PyObject_HasAttrId(obj, &PyId_names)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_names); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); names = _Ta3_asdl_seq_new(len, arena); if (names == NULL) goto failed; for (i = 0; i < len; i++) { identifier value; res = obj2ast_identifier(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Nonlocal field \"names\" changed size during iteration"); goto failed; } asdl_seq_SET(names, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"names\" missing from Nonlocal"); return 1; } *out = Nonlocal(names, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Expr_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Expr"); return 1; } *out = Expr(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Pass_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Pass(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Break_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Break(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Continue_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Continue(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of stmt, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } int obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (_PyObject_HasAttrId(obj, &PyId_lineno)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lineno); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from expr"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_col_offset)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_col_offset); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from expr"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)BoolOp_type); if (isinstance == -1) { return 1; } if (isinstance) { boolop_ty op; asdl_seq* values; if (_PyObject_HasAttrId(obj, &PyId_op)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_op); if (tmp == NULL) goto failed; res = obj2ast_boolop(tmp, &op, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BoolOp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_values)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_values); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = _Ta3_asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration"); goto failed; } asdl_seq_SET(values, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from BoolOp"); return 1; } *out = BoolOp(op, values, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)BinOp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty left; operator_ty op; expr_ty right; if (_PyObject_HasAttrId(obj, &PyId_left)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_left); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &left, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from BinOp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_op)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_op); if (tmp == NULL) goto failed; res = obj2ast_operator(tmp, &op, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from BinOp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_right)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_right); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &right, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"right\" missing from BinOp"); return 1; } *out = BinOp(left, op, right, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)UnaryOp_type); if (isinstance == -1) { return 1; } if (isinstance) { unaryop_ty op; expr_ty operand; if (_PyObject_HasAttrId(obj, &PyId_op)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_op); if (tmp == NULL) goto failed; res = obj2ast_unaryop(tmp, &op, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"op\" missing from UnaryOp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_operand)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_operand); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &operand, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"operand\" missing from UnaryOp"); return 1; } *out = UnaryOp(op, operand, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Lambda_type); if (isinstance == -1) { return 1; } if (isinstance) { arguments_ty args; expr_ty body; if (_PyObject_HasAttrId(obj, &PyId_args)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_args); if (tmp == NULL) goto failed; res = obj2ast_arguments(tmp, &args, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Lambda"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from Lambda"); return 1; } *out = Lambda(args, body, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)IfExp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty test; expr_ty body; expr_ty orelse; if (_PyObject_HasAttrId(obj, &PyId_test)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_test); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &test, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"test\" missing from IfExp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &body, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from IfExp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_orelse)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_orelse); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &orelse, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from IfExp"); return 1; } *out = IfExp(test, body, orelse, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Dict_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* keys; asdl_seq* values; if (_PyObject_HasAttrId(obj, &PyId_keys)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_keys); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); keys = _Ta3_asdl_seq_new(len, arena); if (keys == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration"); goto failed; } asdl_seq_SET(keys, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"keys\" missing from Dict"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_values)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_values); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = _Ta3_asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration"); goto failed; } asdl_seq_SET(values, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from Dict"); return 1; } *out = Dict(keys, values, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Set_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; if (_PyObject_HasAttrId(obj, &PyId_elts)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_elts); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = _Ta3_asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration"); goto failed; } asdl_seq_SET(elts, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Set"); return 1; } *out = Set(elts, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ListComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (_PyObject_HasAttrId(obj, &PyId_elt)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_elt); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from ListComp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_generators)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_generators); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = _Ta3_asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration"); goto failed; } asdl_seq_SET(generators, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from ListComp"); return 1; } *out = ListComp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)SetComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (_PyObject_HasAttrId(obj, &PyId_elt)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_elt); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from SetComp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_generators)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_generators); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = _Ta3_asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration"); goto failed; } asdl_seq_SET(generators, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from SetComp"); return 1; } *out = SetComp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)DictComp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty key; expr_ty value; asdl_seq* generators; if (_PyObject_HasAttrId(obj, &PyId_key)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_key); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &key, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from DictComp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_generators)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_generators); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = _Ta3_asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration"); goto failed; } asdl_seq_SET(generators, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from DictComp"); return 1; } *out = DictComp(key, value, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)GeneratorExp_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty elt; asdl_seq* generators; if (_PyObject_HasAttrId(obj, &PyId_elt)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_elt); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &elt, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from GeneratorExp"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_generators)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_generators); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); generators = _Ta3_asdl_seq_new(len, arena); if (generators == NULL) goto failed; for (i = 0; i < len; i++) { comprehension_ty value; res = obj2ast_comprehension(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration"); goto failed; } asdl_seq_SET(generators, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"generators\" missing from GeneratorExp"); return 1; } *out = GeneratorExp(elt, generators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Await_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Await"); return 1; } *out = Await(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Yield_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (exists_not_none(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { value = NULL; } *out = Yield(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)YieldFrom_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from YieldFrom"); return 1; } *out = YieldFrom(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Compare_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty left; asdl_int_seq* ops; asdl_seq* comparators; if (_PyObject_HasAttrId(obj, &PyId_left)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_left); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &left, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"left\" missing from Compare"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ops)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_ops); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); ops = _Ta3_asdl_int_seq_new(len, arena); if (ops == NULL) goto failed; for (i = 0; i < len; i++) { cmpop_ty value; res = obj2ast_cmpop(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration"); goto failed; } asdl_seq_SET(ops, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ops\" missing from Compare"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_comparators)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_comparators); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); comparators = _Ta3_asdl_seq_new(len, arena); if (comparators == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration"); goto failed; } asdl_seq_SET(comparators, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"comparators\" missing from Compare"); return 1; } *out = Compare(left, ops, comparators, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Call_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty func; asdl_seq* args; asdl_seq* keywords; if (_PyObject_HasAttrId(obj, &PyId_func)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_func); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &func, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"func\" missing from Call"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_args)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_args); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); args = _Ta3_asdl_seq_new(len, arena); if (args == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration"); goto failed; } asdl_seq_SET(args, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from Call"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_keywords)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_keywords); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); keywords = _Ta3_asdl_seq_new(len, arena); if (keywords == NULL) goto failed; for (i = 0; i < len; i++) { keyword_ty value; res = obj2ast_keyword(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration"); goto failed; } asdl_seq_SET(keywords, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call"); return 1; } *out = Call(func, args, keywords, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Num_type); if (isinstance == -1) { return 1; } if (isinstance) { object n; if (_PyObject_HasAttrId(obj, &PyId_n)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_n); if (tmp == NULL) goto failed; res = obj2ast_object(tmp, &n, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"n\" missing from Num"); return 1; } *out = Num(n, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Str_type); if (isinstance == -1) { return 1; } if (isinstance) { string s; if (_PyObject_HasAttrId(obj, &PyId_s)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_s); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &s, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"s\" missing from Str"); return 1; } *out = Str(s, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)FormattedValue_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; int conversion; expr_ty format_spec; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from FormattedValue"); return 1; } if (exists_not_none(obj, &PyId_conversion)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_conversion); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &conversion, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { conversion = 0; } if (exists_not_none(obj, &PyId_format_spec)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_format_spec); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &format_spec, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { format_spec = NULL; } *out = FormattedValue(value, conversion, format_spec, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)JoinedStr_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* values; if (_PyObject_HasAttrId(obj, &PyId_values)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_values); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); values = _Ta3_asdl_seq_new(len, arena); if (values == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "JoinedStr field \"values\" changed size during iteration"); goto failed; } asdl_seq_SET(values, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"values\" missing from JoinedStr"); return 1; } *out = JoinedStr(values, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Bytes_type); if (isinstance == -1) { return 1; } if (isinstance) { bytes s; if (_PyObject_HasAttrId(obj, &PyId_s)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_s); if (tmp == NULL) goto failed; res = obj2ast_bytes(tmp, &s, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"s\" missing from Bytes"); return 1; } *out = Bytes(s, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)NameConstant_type); if (isinstance == -1) { return 1; } if (isinstance) { singleton value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_singleton(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NameConstant"); return 1; } *out = NameConstant(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Ellipsis_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Ellipsis(lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Constant_type); if (isinstance == -1) { return 1; } if (isinstance) { constant value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_constant(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant"); return 1; } *out = Constant(value, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Attribute_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; identifier attr; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Attribute"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_attr)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_attr); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &attr, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"attr\" missing from Attribute"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Attribute"); return 1; } *out = Attribute(value, attr, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Subscript_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; slice_ty slice; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Subscript"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_slice)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_slice); if (tmp == NULL) goto failed; res = obj2ast_slice(tmp, &slice, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"slice\" missing from Subscript"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Subscript"); return 1; } *out = Subscript(value, slice, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Starred_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Starred"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Starred"); return 1; } *out = Starred(value, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Name_type); if (isinstance == -1) { return 1; } if (isinstance) { identifier id; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_id)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_id); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &id, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"id\" missing from Name"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Name"); return 1; } *out = Name(id, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)List_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_elts)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_elts); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = _Ta3_asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration"); goto failed; } asdl_seq_SET(elts, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from List"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from List"); return 1; } *out = List(elts, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Tuple_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* elts; expr_context_ty ctx; if (_PyObject_HasAttrId(obj, &PyId_elts)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_elts); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); elts = _Ta3_asdl_seq_new(len, arena); if (elts == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration"); goto failed; } asdl_seq_SET(elts, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"elts\" missing from Tuple"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ctx)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_ctx); if (tmp == NULL) goto failed; res = obj2ast_expr_context(tmp, &ctx, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ctx\" missing from Tuple"); return 1; } *out = Tuple(elts, ctx, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } int obj2ast_expr_context(PyObject* obj, expr_context_ty* out, PyArena* arena) { int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Load_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Load; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Store_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Store; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Del_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Del; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)AugLoad_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = AugLoad; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)AugStore_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = AugStore; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Param_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Param; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj); return 1; } int obj2ast_slice(PyObject* obj, slice_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Slice_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty lower; expr_ty upper; expr_ty step; if (exists_not_none(obj, &PyId_lower)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lower); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &lower, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { lower = NULL; } if (exists_not_none(obj, &PyId_upper)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_upper); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &upper, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { upper = NULL; } if (exists_not_none(obj, &PyId_step)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_step); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &step, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { step = NULL; } *out = Slice(lower, upper, step, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)ExtSlice_type); if (isinstance == -1) { return 1; } if (isinstance) { asdl_seq* dims; if (_PyObject_HasAttrId(obj, &PyId_dims)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_dims); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ExtSlice field \"dims\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); dims = _Ta3_asdl_seq_new(len, arena); if (dims == NULL) goto failed; for (i = 0; i < len; i++) { slice_ty value; res = obj2ast_slice(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ExtSlice field \"dims\" changed size during iteration"); goto failed; } asdl_seq_SET(dims, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"dims\" missing from ExtSlice"); return 1; } *out = ExtSlice(dims, arena); if (*out == NULL) goto failed; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)Index_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty value; if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Index"); return 1; } *out = Index(value, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of slice, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } int obj2ast_boolop(PyObject* obj, boolop_ty* out, PyArena* arena) { int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)And_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = And; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Or_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Or; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of boolop, but got %R", obj); return 1; } int obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena) { int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Add_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Add; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Sub_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Sub; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Mult_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Mult; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)MatMult_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = MatMult; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Div_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Div; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Mod_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Mod; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Pow_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Pow; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)LShift_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = LShift; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)RShift_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = RShift; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitOr_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitOr; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitXor_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitXor; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)BitAnd_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = BitAnd; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)FloorDiv_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = FloorDiv; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of operator, but got %R", obj); return 1; } int obj2ast_unaryop(PyObject* obj, unaryop_ty* out, PyArena* arena) { int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Invert_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Invert; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Not_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Not; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)UAdd_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = UAdd; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)USub_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = USub; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of unaryop, but got %R", obj); return 1; } int obj2ast_cmpop(PyObject* obj, cmpop_ty* out, PyArena* arena) { int isinstance; isinstance = PyObject_IsInstance(obj, (PyObject *)Eq_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Eq; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)NotEq_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = NotEq; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Lt_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Lt; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)LtE_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = LtE; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Gt_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Gt; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)GtE_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = GtE; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)Is_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = Is; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)IsNot_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = IsNot; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)In_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = In; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject *)NotIn_type); if (isinstance == -1) { return 1; } if (isinstance) { *out = NotIn; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of cmpop, but got %R", obj); return 1; } int obj2ast_comprehension(PyObject* obj, comprehension_ty* out, PyArena* arena) { PyObject* tmp = NULL; expr_ty target; expr_ty iter; asdl_seq* ifs; int is_async; if (_PyObject_HasAttrId(obj, &PyId_target)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_target); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &target, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from comprehension"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_iter)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_iter); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &iter, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from comprehension"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_ifs)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_ifs); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); ifs = _Ta3_asdl_seq_new(len, arena); if (ifs == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration"); goto failed; } asdl_seq_SET(ifs, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"ifs\" missing from comprehension"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_is_async)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_is_async); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &is_async, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"is_async\" missing from comprehension"); return 1; } *out = comprehension(target, iter, ifs, is_async, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_excepthandler(PyObject* obj, excepthandler_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; int lineno; int col_offset; if (obj == Py_None) { *out = NULL; return 0; } if (_PyObject_HasAttrId(obj, &PyId_lineno)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lineno); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from excepthandler"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_col_offset)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_col_offset); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from excepthandler"); return 1; } isinstance = PyObject_IsInstance(obj, (PyObject*)ExceptHandler_type); if (isinstance == -1) { return 1; } if (isinstance) { expr_ty type; identifier name; asdl_seq* body; if (exists_not_none(obj, &PyId_type)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &type, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type = NULL; } if (exists_not_none(obj, &PyId_name)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_name); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { name = NULL; } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_body); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); body = _Ta3_asdl_seq_new(len, arena); if (body == NULL) goto failed; for (i = 0; i < len; i++) { stmt_ty value; res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration"); goto failed; } asdl_seq_SET(body, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from ExceptHandler"); return 1; } *out = ExceptHandler(type, name, body, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of excepthandler, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } int obj2ast_arguments(PyObject* obj, arguments_ty* out, PyArena* arena) { PyObject* tmp = NULL; asdl_seq* args; arg_ty vararg; asdl_seq* kwonlyargs; asdl_seq* kw_defaults; arg_ty kwarg; asdl_seq* defaults; if (_PyObject_HasAttrId(obj, &PyId_args)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_args); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); args = _Ta3_asdl_seq_new(len, arena); if (args == NULL) goto failed; for (i = 0; i < len; i++) { arg_ty value; res = obj2ast_arg(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration"); goto failed; } asdl_seq_SET(args, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from arguments"); return 1; } if (exists_not_none(obj, &PyId_vararg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_vararg); if (tmp == NULL) goto failed; res = obj2ast_arg(tmp, &vararg, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { vararg = NULL; } if (_PyObject_HasAttrId(obj, &PyId_kwonlyargs)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_kwonlyargs); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); kwonlyargs = _Ta3_asdl_seq_new(len, arena); if (kwonlyargs == NULL) goto failed; for (i = 0; i < len; i++) { arg_ty value; res = obj2ast_arg(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "arguments field \"kwonlyargs\" changed size during iteration"); goto failed; } asdl_seq_SET(kwonlyargs, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"kwonlyargs\" missing from arguments"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_kw_defaults)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_kw_defaults); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); kw_defaults = _Ta3_asdl_seq_new(len, arena); if (kw_defaults == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "arguments field \"kw_defaults\" changed size during iteration"); goto failed; } asdl_seq_SET(kw_defaults, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"kw_defaults\" missing from arguments"); return 1; } if (exists_not_none(obj, &PyId_kwarg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_kwarg); if (tmp == NULL) goto failed; res = obj2ast_arg(tmp, &kwarg, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { kwarg = NULL; } if (_PyObject_HasAttrId(obj, &PyId_defaults)) { int res; Py_ssize_t len; Py_ssize_t i; tmp = _PyObject_GetAttrId(obj, &PyId_defaults); if (tmp == NULL) goto failed; if (!PyList_Check(tmp)) { PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", tmp->ob_type->tp_name); goto failed; } len = PyList_GET_SIZE(tmp); defaults = _Ta3_asdl_seq_new(len, arena); if (defaults == NULL) goto failed; for (i = 0; i < len; i++) { expr_ty value; res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); if (res != 0) goto failed; if (len != PyList_GET_SIZE(tmp)) { PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration"); goto failed; } asdl_seq_SET(defaults, i, value); } Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"defaults\" missing from arguments"); return 1; } *out = arguments(args, vararg, kwonlyargs, kw_defaults, kwarg, defaults, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena) { PyObject* tmp = NULL; identifier arg; expr_ty annotation; string type_comment; int lineno; int col_offset; if (_PyObject_HasAttrId(obj, &PyId_arg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_arg); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &arg, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from arg"); return 1; } if (exists_not_none(obj, &PyId_annotation)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_annotation); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &annotation, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { annotation = NULL; } if (exists_not_none(obj, &PyId_type_comment)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_type_comment); if (tmp == NULL) goto failed; res = obj2ast_string(tmp, &type_comment, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { type_comment = NULL; } if (_PyObject_HasAttrId(obj, &PyId_lineno)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lineno); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from arg"); return 1; } if (_PyObject_HasAttrId(obj, &PyId_col_offset)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_col_offset); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &col_offset, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from arg"); return 1; } *out = arg(arg, annotation, type_comment, lineno, col_offset, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena) { PyObject* tmp = NULL; identifier arg; expr_ty value; if (exists_not_none(obj, &PyId_arg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_arg); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &arg, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { arg = NULL; } if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_value); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &value, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from keyword"); return 1; } *out = keyword(arg, value, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_alias(PyObject* obj, alias_ty* out, PyArena* arena) { PyObject* tmp = NULL; identifier name; identifier asname; if (_PyObject_HasAttrId(obj, &PyId_name)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_name); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &name, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from alias"); return 1; } if (exists_not_none(obj, &PyId_asname)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_asname); if (tmp == NULL) goto failed; res = obj2ast_identifier(tmp, &asname, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { asname = NULL; } *out = alias(name, asname, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_withitem(PyObject* obj, withitem_ty* out, PyArena* arena) { PyObject* tmp = NULL; expr_ty context_expr; expr_ty optional_vars; if (_PyObject_HasAttrId(obj, &PyId_context_expr)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_context_expr); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &context_expr, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"context_expr\" missing from withitem"); return 1; } if (exists_not_none(obj, &PyId_optional_vars)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_optional_vars); if (tmp == NULL) goto failed; res = obj2ast_expr(tmp, &optional_vars, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { optional_vars = NULL; } *out = withitem(context_expr, optional_vars, arena); return 0; failed: Py_XDECREF(tmp); return 1; } int obj2ast_type_ignore(PyObject* obj, type_ignore_ty* out, PyArena* arena) { int isinstance; PyObject *tmp = NULL; if (obj == Py_None) { *out = NULL; return 0; } isinstance = PyObject_IsInstance(obj, (PyObject*)TypeIgnore_type); if (isinstance == -1) { return 1; } if (isinstance) { int lineno; if (_PyObject_HasAttrId(obj, &PyId_lineno)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_lineno); if (tmp == NULL) goto failed; res = obj2ast_int(tmp, &lineno, arena); if (res != 0) goto failed; Py_CLEAR(tmp); } else { PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore"); return 1; } *out = TypeIgnore(lineno, arena); if (*out == NULL) goto failed; return 0; } PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj); failed: Py_XDECREF(tmp); return 1; } PyObject *ast3_parse(PyObject *self, PyObject *args); static PyMethodDef ast3_methods[] = { {"_parse", ast3_parse, METH_VARARGS, "Parse string into typed AST."}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef _astmodule3 = { PyModuleDef_HEAD_INIT, "_ast3", NULL, 0, ast3_methods }; PyMODINIT_FUNC PyInit__ast3(void) { PyObject *m, *d; if (!init_types()) return NULL; m = PyModule_Create(&_astmodule3); if (!m) return NULL; d = PyModule_GetDict(m); if (PyDict_SetItemString(d, "AST", (PyObject*)&AST_type) < 0) return NULL; if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) return NULL; if (PyDict_SetItemString(d, "mod", (PyObject*)mod_type) < 0) return NULL; if (PyDict_SetItemString(d, "Module", (PyObject*)Module_type) < 0) return NULL; if (PyDict_SetItemString(d, "Interactive", (PyObject*)Interactive_type) < 0) return NULL; if (PyDict_SetItemString(d, "Expression", (PyObject*)Expression_type) < 0) return NULL; if (PyDict_SetItemString(d, "FunctionType", (PyObject*)FunctionType_type) < 0) return NULL; if (PyDict_SetItemString(d, "Suite", (PyObject*)Suite_type) < 0) return NULL; if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return NULL; if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "AsyncFunctionDef", (PyObject*)AsyncFunctionDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0) return NULL; if (PyDict_SetItemString(d, "Delete", (PyObject*)Delete_type) < 0) return NULL; if (PyDict_SetItemString(d, "Assign", (PyObject*)Assign_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) < 0) return NULL; if (PyDict_SetItemString(d, "AnnAssign", (PyObject*)AnnAssign_type) < 0) return NULL; if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return NULL; if (PyDict_SetItemString(d, "AsyncFor", (PyObject*)AsyncFor_type) < 0) return NULL; if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return NULL; if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return NULL; if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return NULL; if (PyDict_SetItemString(d, "AsyncWith", (PyObject*)AsyncWith_type) < 0) return NULL; if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return NULL; if (PyDict_SetItemString(d, "Try", (PyObject*)Try_type) < 0) return NULL; if (PyDict_SetItemString(d, "Assert", (PyObject*)Assert_type) < 0) return NULL; if (PyDict_SetItemString(d, "Import", (PyObject*)Import_type) < 0) return NULL; if (PyDict_SetItemString(d, "ImportFrom", (PyObject*)ImportFrom_type) < 0) return NULL; if (PyDict_SetItemString(d, "Global", (PyObject*)Global_type) < 0) return NULL; if (PyDict_SetItemString(d, "Nonlocal", (PyObject*)Nonlocal_type) < 0) return NULL; if (PyDict_SetItemString(d, "Expr", (PyObject*)Expr_type) < 0) return NULL; if (PyDict_SetItemString(d, "Pass", (PyObject*)Pass_type) < 0) return NULL; if (PyDict_SetItemString(d, "Break", (PyObject*)Break_type) < 0) return NULL; if (PyDict_SetItemString(d, "Continue", (PyObject*)Continue_type) < 0) return NULL; if (PyDict_SetItemString(d, "expr", (PyObject*)expr_type) < 0) return NULL; if (PyDict_SetItemString(d, "BoolOp", (PyObject*)BoolOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "BinOp", (PyObject*)BinOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "UnaryOp", (PyObject*)UnaryOp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Lambda", (PyObject*)Lambda_type) < 0) return NULL; if (PyDict_SetItemString(d, "IfExp", (PyObject*)IfExp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Dict", (PyObject*)Dict_type) < 0) return NULL; if (PyDict_SetItemString(d, "Set", (PyObject*)Set_type) < 0) return NULL; if (PyDict_SetItemString(d, "ListComp", (PyObject*)ListComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "SetComp", (PyObject*)SetComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "DictComp", (PyObject*)DictComp_type) < 0) return NULL; if (PyDict_SetItemString(d, "GeneratorExp", (PyObject*)GeneratorExp_type) < 0) return NULL; if (PyDict_SetItemString(d, "Await", (PyObject*)Await_type) < 0) return NULL; if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return NULL; if (PyDict_SetItemString(d, "YieldFrom", (PyObject*)YieldFrom_type) < 0) return NULL; if (PyDict_SetItemString(d, "Compare", (PyObject*)Compare_type) < 0) return NULL; if (PyDict_SetItemString(d, "Call", (PyObject*)Call_type) < 0) return NULL; if (PyDict_SetItemString(d, "Num", (PyObject*)Num_type) < 0) return NULL; if (PyDict_SetItemString(d, "Str", (PyObject*)Str_type) < 0) return NULL; if (PyDict_SetItemString(d, "FormattedValue", (PyObject*)FormattedValue_type) < 0) return NULL; if (PyDict_SetItemString(d, "JoinedStr", (PyObject*)JoinedStr_type) < 0) return NULL; if (PyDict_SetItemString(d, "Bytes", (PyObject*)Bytes_type) < 0) return NULL; if (PyDict_SetItemString(d, "NameConstant", (PyObject*)NameConstant_type) < 0) return NULL; if (PyDict_SetItemString(d, "Ellipsis", (PyObject*)Ellipsis_type) < 0) return NULL; if (PyDict_SetItemString(d, "Constant", (PyObject*)Constant_type) < 0) return NULL; if (PyDict_SetItemString(d, "Attribute", (PyObject*)Attribute_type) < 0) return NULL; if (PyDict_SetItemString(d, "Subscript", (PyObject*)Subscript_type) < 0) return NULL; if (PyDict_SetItemString(d, "Starred", (PyObject*)Starred_type) < 0) return NULL; if (PyDict_SetItemString(d, "Name", (PyObject*)Name_type) < 0) return NULL; if (PyDict_SetItemString(d, "List", (PyObject*)List_type) < 0) return NULL; if (PyDict_SetItemString(d, "Tuple", (PyObject*)Tuple_type) < 0) return NULL; if (PyDict_SetItemString(d, "expr_context", (PyObject*)expr_context_type) < 0) return NULL; if (PyDict_SetItemString(d, "Load", (PyObject*)Load_type) < 0) return NULL; if (PyDict_SetItemString(d, "Store", (PyObject*)Store_type) < 0) return NULL; if (PyDict_SetItemString(d, "Del", (PyObject*)Del_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugLoad", (PyObject*)AugLoad_type) < 0) return NULL; if (PyDict_SetItemString(d, "AugStore", (PyObject*)AugStore_type) < 0) return NULL; if (PyDict_SetItemString(d, "Param", (PyObject*)Param_type) < 0) return NULL; if (PyDict_SetItemString(d, "slice", (PyObject*)slice_type) < 0) return NULL; if (PyDict_SetItemString(d, "Slice", (PyObject*)Slice_type) < 0) return NULL; if (PyDict_SetItemString(d, "ExtSlice", (PyObject*)ExtSlice_type) < 0) return NULL; if (PyDict_SetItemString(d, "Index", (PyObject*)Index_type) < 0) return NULL; if (PyDict_SetItemString(d, "boolop", (PyObject*)boolop_type) < 0) return NULL; if (PyDict_SetItemString(d, "And", (PyObject*)And_type) < 0) return NULL; if (PyDict_SetItemString(d, "Or", (PyObject*)Or_type) < 0) return NULL; if (PyDict_SetItemString(d, "operator", (PyObject*)operator_type) < 0) return NULL; if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return NULL; if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return NULL; if (PyDict_SetItemString(d, "MatMult", (PyObject*)MatMult_type) < 0) return NULL; if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return NULL; if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return NULL; if (PyDict_SetItemString(d, "LShift", (PyObject*)LShift_type) < 0) return NULL; if (PyDict_SetItemString(d, "RShift", (PyObject*)RShift_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitOr", (PyObject*)BitOr_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitXor", (PyObject*)BitXor_type) < 0) return NULL; if (PyDict_SetItemString(d, "BitAnd", (PyObject*)BitAnd_type) < 0) return NULL; if (PyDict_SetItemString(d, "FloorDiv", (PyObject*)FloorDiv_type) < 0) return NULL; if (PyDict_SetItemString(d, "unaryop", (PyObject*)unaryop_type) < 0) return NULL; if (PyDict_SetItemString(d, "Invert", (PyObject*)Invert_type) < 0) return NULL; if (PyDict_SetItemString(d, "Not", (PyObject*)Not_type) < 0) return NULL; if (PyDict_SetItemString(d, "UAdd", (PyObject*)UAdd_type) < 0) return NULL; if (PyDict_SetItemString(d, "USub", (PyObject*)USub_type) < 0) return NULL; if (PyDict_SetItemString(d, "cmpop", (PyObject*)cmpop_type) < 0) return NULL; if (PyDict_SetItemString(d, "Eq", (PyObject*)Eq_type) < 0) return NULL; if (PyDict_SetItemString(d, "NotEq", (PyObject*)NotEq_type) < 0) return NULL; if (PyDict_SetItemString(d, "Lt", (PyObject*)Lt_type) < 0) return NULL; if (PyDict_SetItemString(d, "LtE", (PyObject*)LtE_type) < 0) return NULL; if (PyDict_SetItemString(d, "Gt", (PyObject*)Gt_type) < 0) return NULL; if (PyDict_SetItemString(d, "GtE", (PyObject*)GtE_type) < 0) return NULL; if (PyDict_SetItemString(d, "Is", (PyObject*)Is_type) < 0) return NULL; if (PyDict_SetItemString(d, "IsNot", (PyObject*)IsNot_type) < 0) return NULL; if (PyDict_SetItemString(d, "In", (PyObject*)In_type) < 0) return NULL; if (PyDict_SetItemString(d, "NotIn", (PyObject*)NotIn_type) < 0) return NULL; if (PyDict_SetItemString(d, "comprehension", (PyObject*)comprehension_type) < 0) return NULL; if (PyDict_SetItemString(d, "excepthandler", (PyObject*)excepthandler_type) < 0) return NULL; if (PyDict_SetItemString(d, "ExceptHandler", (PyObject*)ExceptHandler_type) < 0) return NULL; if (PyDict_SetItemString(d, "arguments", (PyObject*)arguments_type) < 0) return NULL; if (PyDict_SetItemString(d, "arg", (PyObject*)arg_type) < 0) return NULL; if (PyDict_SetItemString(d, "keyword", (PyObject*)keyword_type) < 0) return NULL; if (PyDict_SetItemString(d, "alias", (PyObject*)alias_type) < 0) return NULL; if (PyDict_SetItemString(d, "withitem", (PyObject*)withitem_type) < 0) return NULL; if (PyDict_SetItemString(d, "type_ignore", (PyObject*)type_ignore_type) < 0) return NULL; if (PyDict_SetItemString(d, "TypeIgnore", (PyObject*)TypeIgnore_type) < 0) return NULL; return m; } PyObject* Ta3AST_mod2obj(mod_ty t) { if (!init_types()) return NULL; return ast2obj_mod(t); } /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */ mod_ty Ta3AST_obj2mod(PyObject* ast, PyArena* arena, int mode) { mod_ty res; PyObject *req_type[3]; char *req_name[] = {"Module", "Expression", "Interactive"}; int isinstance; req_type[0] = (PyObject*)Module_type; req_type[1] = (PyObject*)Expression_type; req_type[2] = (PyObject*)Interactive_type; assert(0 <= mode && mode <= 2); if (!init_types()) return NULL; isinstance = PyObject_IsInstance(ast, req_type[mode]); if (isinstance == -1) return NULL; if (!isinstance) { PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s", req_name[mode], Py_TYPE(ast)->tp_name); return NULL; } if (obj2ast_mod(ast, &res, arena) != 0) return NULL; else return res; } int Ta3AST_Check(PyObject* obj) { if (!init_types()) return -1; return PyObject_IsInstance(obj, (PyObject*)&AST_type); } typed-ast-1.1.0/LICENSE0000644€Tøžæ€2›s®0000003552713050216645015743 0ustar ddfisher00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: typed-ast Source: https://pypi.python.org/pypi/typed-ast Files: * Copyright: © 2016 David Fisher License: Apache-2.0 Files: * Copyright: © 2016 David Fisher © 2008 Armin Ronacher Comment: The original CPython source is licensed under the Python Software Foundation License Version 2 License: Python Files: ast27/Parser/spark.py Copyright: © 1998-2002 John Aycock License: Expat Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. License: Apache-2.0 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ . TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION . 1. Definitions. . "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. . "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. . "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. . "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. . "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. . "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. . "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). . "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. . "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." . "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. . 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. . 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. . 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: . (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and . (b) You must cause any modified files to carry prominent notices stating that You changed the files; and . (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and . (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. . You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. . 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. . 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. . 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. . 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. . 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. . END OF TERMS AND CONDITIONS . APPENDIX: How to apply the Apache License to your work. . To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. . Copyright 2016 Dropbox, Inc. . Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at . http://www.apache.org/licenses/LICENSE-2.0 . Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. License: Python PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 -------------------------------------------- . 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated documentation. . 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee. . 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python. . 4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. . 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. . 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. . 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. . 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement. typed-ast-1.1.0/MANIFEST.in0000644€Tøžæ€2›s®0000000010713050216645016456 0ustar ddfisher00000000000000recursive-include ast27 *.h recursive-include ast3 *.h include LICENSE typed-ast-1.1.0/PKG-INFO0000644€Tøžæ€2›s®0000000231313133476735016030 0ustar ddfisher00000000000000Metadata-Version: 1.1 Name: typed-ast Version: 1.1.0 Summary: a fork of Python 2 and 3 ast modules with type comment support Home-page: https://github.com/python/typed_ast Author: David Fisher Author-email: ddfisher@dropbox.com License: Apache License 2.0 Description: `typed_ast` is a Python 3 package that provides a Python 2.7 and Python 3 parser similar to the standard `ast` library. Unlike `ast`, the parsers in `typed_ast` include PEP 484 type comments and are independent of the version of Python under which they are run. The `typed_ast` parsers produce the standard Python AST (plus type comments), and are both fast and correct, as they are based on the CPython 2.7 and 3.6 parsers. Platform: POSIX Platform: Windows Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: Operating System :: POSIX Classifier: Operating System :: Microsoft Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Topic :: Software Development typed-ast-1.1.0/setup.cfg0000644€Tøžæ€2›s®0000000004613133476735016555 0ustar ddfisher00000000000000[egg_info] tag_build = tag_date = 0 typed-ast-1.1.0/setup.py0000644€Tøžæ€2›s®0000000717313133476150016445 0ustar ddfisher00000000000000import sys if sys.version_info[0] < 3 or sys.version_info[1] < 3: sys.exit('Error: typed_ast only runs on Python 3.3 and above.') try: from setuptools import setup, Extension except ImportError: from distutils.core import setup, Extension _ast27 = Extension( '_ast27', include_dirs = ['ast27/Include'], sources = [ 'ast27/Parser/acceler.c', 'ast27/Parser/bitset.c', 'ast27/Parser/grammar.c', 'ast27/Parser/grammar1.c', 'ast27/Parser/node.c', 'ast27/Parser/parser.c', 'ast27/Parser/parsetok.c', 'ast27/Parser/tokenizer.c', 'ast27/Python/asdl.c', 'ast27/Python/ast.c', 'ast27/Python/graminit.c', 'ast27/Python/mystrtoul.c', 'ast27/Python/Python-ast.c', 'ast27/Custom/typed_ast.c', ], depends = [ 'ast27/Include/asdl.h', 'ast27/Include/ast.h', 'ast27/Include/bitset.h', 'ast27/Include/compile.h', 'ast27/Include/errcode.h', 'ast27/Include/graminit.h', 'ast27/Include/grammar.h', 'ast27/Include/node.h', 'ast27/Include/parsetok.h', 'ast27/Include/Python-ast.h', 'ast27/Include/token.h', 'ast27/Parser/parser.h', 'ast27/Parser/tokenizer.h', ]) _ast3 = Extension( '_ast3', include_dirs = ['ast3/Include'], sources = [ 'ast3/Parser/acceler.c', 'ast3/Parser/bitset.c', 'ast3/Parser/grammar.c', 'ast3/Parser/grammar1.c', 'ast3/Parser/node.c', 'ast3/Parser/parser.c', 'ast3/Parser/parsetok.c', 'ast3/Parser/tokenizer.c', 'ast3/Python/asdl.c', 'ast3/Python/ast.c', 'ast3/Python/graminit.c', 'ast3/Python/Python-ast.c', 'ast3/Custom/typed_ast.c', ], depends = [ 'ast3/Include/asdl.h', 'ast3/Include/ast.h', 'ast3/Include/bitset.h', 'ast3/Include/compile.h', 'ast3/Include/errcode.h', 'ast3/Include/graminit.h', 'ast3/Include/grammar.h', 'ast3/Include/node.h', 'ast3/Include/parsetok.h', 'ast3/Include/Python-ast.h', 'ast3/Include/token.h', 'ast3/Parser/parser.h', 'ast3/Parser/tokenizer.h', ]) long_description = """ `typed_ast` is a Python 3 package that provides a Python 2.7 and Python 3 parser similar to the standard `ast` library. Unlike `ast`, the parsers in `typed_ast` include PEP 484 type comments and are independent of the version of Python under which they are run. The `typed_ast` parsers produce the standard Python AST (plus type comments), and are both fast and correct, as they are based on the CPython 2.7 and 3.6 parsers. """.strip() setup (name = 'typed-ast', version = '1.1.0', description = 'a fork of Python 2 and 3 ast modules with type comment support', long_description = long_description, author = 'David Fisher', author_email = 'ddfisher@dropbox.com', url = 'https://github.com/python/typed_ast', license='Apache License 2.0', platforms = ['POSIX', 'Windows'], classifiers = [ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Operating System :: POSIX', 'Operating System :: Microsoft', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Topic :: Software Development', ], packages = ['typed_ast'], ext_modules = [_ast27, _ast3]) typed-ast-1.1.0/typed_ast/0000755€Tøžæ€2›s®0000000000013133476735016730 5ustar ddfisher00000000000000typed-ast-1.1.0/typed_ast/__init__.py0000644€Tøžæ€2›s®0000000000113050212020020775 0ustar ddfisher00000000000000 typed-ast-1.1.0/typed_ast/ast27.py0000644€Tøžæ€2›s®0000003051513050216645020234 0ustar ddfisher00000000000000# -*- coding: utf-8 -*- """ ast27 ~~~ The `ast27` module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this module helps to find out programmatically what the current grammar looks like and allows modifications of it. The `ast27` module is similar to the builtin `ast` module on Python 2.7, except `ast27` runs on Python 3 and provides PEP 484 type comments as part of the AST. Specifically, these changes are made to the Python 2.7 AST: - The `FunctionDef`, `Assign`, `For`, and `With` classes all have a `type_comment` field which contains a `str` with the text of the associated type comment, if any. - `arguments` has a `type_comments` list of per-argument type comments. - `parse` has been augmented so it can parse function signature types when called with `mode=func_type`. - `Module` has a `type_ignores` field which contains a list of lines which have been `# type: ignore`d. - `Str` has a `has_b` boolean field which indicates if the string is explicitly prefixed with a `b`. (This is deprecated and may be removed in future versions.) An abstract syntax tree can be generated by using the `parse()` function from this module. The result will be a tree of objects whose classes all inherit from `ast27.AST`. A modified abstract syntax tree can be compiled into a Python code object using the built-in `compile()` function. Additionally various helper functions are provided that make working with the trees simpler. The main intention of the helper functions and this module in general is to provide an easy to use interface for libraries that work tightly with the python syntax (template engines for example). :copyright: Copyright 2008 by Armin Ronacher. :license: Python License. """ import _ast27 from _ast27 import * def parse(source, filename='', mode='exec'): """ Parse the source into an AST node with type comments. Equivalent to compile(source, filename, mode, PyCF_ONLY_AST). """ return _ast27.parse(source, filename, mode) def literal_eval(node_or_string): """ Safely evaluate an expression node or a string containing a Python expression. The string or node provided may only consist of the following Python literal structures: strings, numbers, tuples, lists, dicts, booleans, and None. """ _safe_names = {'None': None, 'True': True, 'False': False} if isinstance(node_or_string, basestring): node_or_string = parse(node_or_string, mode='eval') if isinstance(node_or_string, Expression): node_or_string = node_or_string.body def _convert(node): if isinstance(node, Str): return node.s elif isinstance(node, Num): return node.n elif isinstance(node, Tuple): return tuple(map(_convert, node.elts)) elif isinstance(node, List): return list(map(_convert, node.elts)) elif isinstance(node, Dict): return dict((_convert(k), _convert(v)) for k, v in zip(node.keys, node.values)) elif isinstance(node, Name): if node.id in _safe_names: return _safe_names[node.id] elif isinstance(node, BinOp) and \ isinstance(node.op, (Add, Sub)) and \ isinstance(node.right, Num) and \ isinstance(node.right.n, complex) and \ isinstance(node.left, Num) and \ isinstance(node.left.n, (int, long, float)): left = node.left.n right = node.right.n if isinstance(node.op, Add): return left + right else: return left - right raise ValueError('malformed string') return _convert(node_or_string) def dump(node, annotate_fields=True, include_attributes=False): """ Return a formatted dump of the tree in *node*. This is mainly useful for debugging purposes. The returned string will show the names and the values for fields. This makes the code impossible to evaluate, so if evaluation is wanted *annotate_fields* must be set to False. Attributes such as line numbers and column offsets are not dumped by default. If this is wanted, *include_attributes* can be set to True. """ def _format(node): if isinstance(node, AST): fields = [(a, _format(b)) for a, b in iter_fields(node)] rv = '%s(%s' % (node.__class__.__name__, ', '.join( ('%s=%s' % field for field in fields) if annotate_fields else (b for a, b in fields) )) if include_attributes and node._attributes: rv += fields and ', ' or ' ' rv += ', '.join('%s=%s' % (a, _format(getattr(node, a))) for a in node._attributes) return rv + ')' elif isinstance(node, list): return '[%s]' % ', '.join(_format(x) for x in node) return repr(node) if not isinstance(node, AST): raise TypeError('expected AST, got %r' % node.__class__.__name__) return _format(node) def copy_location(new_node, old_node): """ Copy source location (`lineno` and `col_offset` attributes) from *old_node* to *new_node* if possible, and return *new_node*. """ for attr in 'lineno', 'col_offset': if attr in old_node._attributes and attr in new_node._attributes \ and hasattr(old_node, attr): setattr(new_node, attr, getattr(old_node, attr)) return new_node def fix_missing_locations(node): """ When you compile a node tree with compile(), the compiler expects lineno and col_offset attributes for every node that supports them. This is rather tedious to fill in for generated nodes, so this helper adds these attributes recursively where not already set, by setting them to the values of the parent node. It works recursively starting at *node*. """ def _fix(node, lineno, col_offset): if 'lineno' in node._attributes: if not hasattr(node, 'lineno'): node.lineno = lineno else: lineno = node.lineno if 'col_offset' in node._attributes: if not hasattr(node, 'col_offset'): node.col_offset = col_offset else: col_offset = node.col_offset for child in iter_child_nodes(node): _fix(child, lineno, col_offset) _fix(node, 1, 0) return node def increment_lineno(node, n=1): """ Increment the line number of each node in the tree starting at *node* by *n*. This is useful to "move code" to a different location in a file. """ for child in walk(node): if 'lineno' in child._attributes: child.lineno = getattr(child, 'lineno', 0) + n return node def iter_fields(node): """ Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields`` that is present on *node*. """ for field in node._fields: try: yield field, getattr(node, field) except AttributeError: pass def iter_child_nodes(node): """ Yield all direct child nodes of *node*, that is, all fields that are nodes and all items of fields that are lists of nodes. """ for name, field in iter_fields(node): if isinstance(field, AST): yield field elif isinstance(field, list): for item in field: if isinstance(item, AST): yield item def get_docstring(node, clean=True): """ Return the docstring for the given node or None if no docstring can be found. If the node provided does not have docstrings a TypeError will be raised. """ if not isinstance(node, (FunctionDef, ClassDef, Module)): raise TypeError("%r can't have docstrings" % node.__class__.__name__) if node.body and isinstance(node.body[0], Expr) and \ isinstance(node.body[0].value, Str): if clean: import inspect return inspect.cleandoc(node.body[0].value.s) return node.body[0].value.s def walk(node): """ Recursively yield all descendant nodes in the tree starting at *node* (including *node* itself), in no specified order. This is useful if you only want to modify nodes in place and don't care about the context. """ from collections import deque todo = deque([node]) while todo: node = todo.popleft() todo.extend(iter_child_nodes(node)) yield node class NodeVisitor(object): """ A node visitor base class that walks the abstract syntax tree and calls a visitor function for every node found. This function may return a value which is forwarded by the `visit` method. This class is meant to be subclassed, with the subclass adding visitor methods. Per default the visitor functions for the nodes are ``'visit_'`` + class name of the node. So a `TryFinally` node visit function would be `visit_TryFinally`. This behavior can be changed by overriding the `visit` method. If no visitor function exists for a node (return value `None`) the `generic_visit` visitor is used instead. Don't use the `NodeVisitor` if you want to apply changes to nodes during traversing. For this a special visitor exists (`NodeTransformer`) that allows modifications. """ def visit(self, node): """Visit a node.""" method = 'visit_' + node.__class__.__name__ visitor = getattr(self, method, self.generic_visit) return visitor(node) def generic_visit(self, node): """Called if no explicit visitor function exists for a node.""" for field, value in iter_fields(node): if isinstance(value, list): for item in value: if isinstance(item, AST): self.visit(item) elif isinstance(value, AST): self.visit(value) class NodeTransformer(NodeVisitor): """ A :class:`NodeVisitor` subclass that walks the abstract syntax tree and allows modification of nodes. The `NodeTransformer` will walk the AST and use the return value of the visitor methods to replace or remove the old node. If the return value of the visitor method is ``None``, the node will be removed from its location, otherwise it is replaced with the return value. The return value may be the original node in which case no replacement takes place. Here is an example transformer that rewrites all occurrences of name lookups (``foo``) to ``data['foo']``:: class RewriteName(NodeTransformer): def visit_Name(self, node): return copy_location(Subscript( value=Name(id='data', ctx=Load()), slice=Index(value=Str(s=node.id)), ctx=node.ctx ), node) Keep in mind that if the node you're operating on has child nodes you must either transform the child nodes yourself or call the :meth:`generic_visit` method for the node first. For nodes that were part of a collection of statements (that applies to all statement nodes), the visitor may also return a list of nodes rather than just a single node. Usually you use the transformer like this:: node = YourTransformer().visit(node) """ def generic_visit(self, node): for field, old_value in iter_fields(node): old_value = getattr(node, field, None) if isinstance(old_value, list): new_values = [] for value in old_value: if isinstance(value, AST): value = self.visit(value) if value is None: continue elif not isinstance(value, AST): new_values.extend(value) continue new_values.append(value) old_value[:] = new_values elif isinstance(old_value, AST): new_node = self.visit(old_value) if new_node is None: delattr(node, field) else: setattr(node, field, new_node) return node typed-ast-1.1.0/typed_ast/ast3.py0000644€Tøžæ€2›s®0000003230713120100330020124 0ustar ddfisher00000000000000""" typed_ast.ast3 ~~~ The `ast3` module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this module helps to find out programmatically what the current grammar looks like and allows modifications of it. The difference between the `ast3` module and the builtin `ast` module is that `ast3` is version-independent and provides PEP 484 type comments as part of the AST. Specifically, these changes are made to the latest Python 3 AST: - The `FunctionDef`, `AsyncFunctionDef`, `Assign`, `For`, `AsyncFor`, `With`, `AsyncWith`, and `arg` classes all have a `type_comment` field which contains a `str` with the text of the associated type comment, if any. - `parse` has been augmented so it can parse function signature types when called with `mode=func_type`. - `parse` has an additional argument `feature_version`, which disables newer Python syntax features. - `Module` has a `type_ignores` field which contains a list of lines which have been `# type: ignore`d. An abstract syntax tree can be generated by using the `parse()` function from this module. The result will be a tree of objects whose classes all inherit from `ast3.AST`. Additionally various helper functions are provided that make working with the trees simpler. The main intention of the helper functions and this module in general is to provide an easy to use interface for libraries that work tightly with the python syntax (template engines for example). :copyright: Copyright 2008 by Armin Ronacher. :license: Python License. """ import _ast3 from _ast3 import * LATEST_MINOR_VERSION = 6 def parse(source, filename='', mode='exec', feature_version=LATEST_MINOR_VERSION): """ Parse the source into an AST node including type comments. Similar to compile(source, filename, mode, PyCF_ONLY_AST). Set feature_version to limit the syntax parsed to that minor version of Python 3. For example, feature_version=5 will prevent new syntax features from Python 3.6+ from being used, such as fstrings. Currently only fully supported for Python 3.5+ with partial support for Python 3.4. So, feature_version=3 or less are all equivalent to feature_version=4. When feature_version=4, the parser will forbid the use of the async/await keywords and the '@' operator, but will not forbid the use of PEP 448 additional unpacking generalizations, which were also added in Python 3.5. """ return _ast3._parse(source, filename, mode, feature_version) _NUM_TYPES = (int, float, complex) def literal_eval(node_or_string): """ Safely evaluate an expression node or a string containing a Python expression. The string or node provided may only consist of the following Python literal structures: strings, bytes, numbers, tuples, lists, dicts, sets, booleans, and None. """ if isinstance(node_or_string, str): node_or_string = parse(node_or_string, mode='eval') if isinstance(node_or_string, Expression): node_or_string = node_or_string.body def _convert(node): if isinstance(node, Constant): return node.value elif isinstance(node, (Str, Bytes)): return node.s elif isinstance(node, Num): return node.n elif isinstance(node, Tuple): return tuple(map(_convert, node.elts)) elif isinstance(node, List): return list(map(_convert, node.elts)) elif isinstance(node, Set): return set(map(_convert, node.elts)) elif isinstance(node, Dict): return dict((_convert(k), _convert(v)) for k, v in zip(node.keys, node.values)) elif isinstance(node, NameConstant): return node.value elif isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)): operand = _convert(node.operand) if isinstance(operand, _NUM_TYPES): if isinstance(node.op, UAdd): return + operand else: return - operand elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)): left = _convert(node.left) right = _convert(node.right) if isinstance(left, _NUM_TYPES) and isinstance(right, _NUM_TYPES): if isinstance(node.op, Add): return left + right else: return left - right raise ValueError('malformed node or string: ' + repr(node)) return _convert(node_or_string) def dump(node, annotate_fields=True, include_attributes=False): """ Return a formatted dump of the tree in *node*. This is mainly useful for debugging purposes. The returned string will show the names and the values for fields. This makes the code impossible to evaluate, so if evaluation is wanted *annotate_fields* must be set to False. Attributes such as line numbers and column offsets are not dumped by default. If this is wanted, *include_attributes* can be set to True. """ def _format(node): if isinstance(node, AST): fields = [(a, _format(b)) for a, b in iter_fields(node)] rv = '%s(%s' % (node.__class__.__name__, ', '.join( ('%s=%s' % field for field in fields) if annotate_fields else (b for a, b in fields) )) if include_attributes and node._attributes: rv += fields and ', ' or ' ' rv += ', '.join('%s=%s' % (a, _format(getattr(node, a))) for a in node._attributes) return rv + ')' elif isinstance(node, list): return '[%s]' % ', '.join(_format(x) for x in node) return repr(node) if not isinstance(node, AST): raise TypeError('expected AST, got %r' % node.__class__.__name__) return _format(node) def copy_location(new_node, old_node): """ Copy source location (`lineno` and `col_offset` attributes) from *old_node* to *new_node* if possible, and return *new_node*. """ for attr in 'lineno', 'col_offset': if attr in old_node._attributes and attr in new_node._attributes \ and hasattr(old_node, attr): setattr(new_node, attr, getattr(old_node, attr)) return new_node def fix_missing_locations(node): """ When you compile a node tree with compile(), the compiler expects lineno and col_offset attributes for every node that supports them. This is rather tedious to fill in for generated nodes, so this helper adds these attributes recursively where not already set, by setting them to the values of the parent node. It works recursively starting at *node*. """ def _fix(node, lineno, col_offset): if 'lineno' in node._attributes: if not hasattr(node, 'lineno'): node.lineno = lineno else: lineno = node.lineno if 'col_offset' in node._attributes: if not hasattr(node, 'col_offset'): node.col_offset = col_offset else: col_offset = node.col_offset for child in iter_child_nodes(node): _fix(child, lineno, col_offset) _fix(node, 1, 0) return node def increment_lineno(node, n=1): """ Increment the line number of each node in the tree starting at *node* by *n*. This is useful to "move code" to a different location in a file. """ for child in walk(node): if 'lineno' in child._attributes: child.lineno = getattr(child, 'lineno', 0) + n return node def iter_fields(node): """ Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields`` that is present on *node*. """ for field in node._fields: try: yield field, getattr(node, field) except AttributeError: pass def iter_child_nodes(node): """ Yield all direct child nodes of *node*, that is, all fields that are nodes and all items of fields that are lists of nodes. """ for name, field in iter_fields(node): if isinstance(field, AST): yield field elif isinstance(field, list): for item in field: if isinstance(item, AST): yield item def get_docstring(node, clean=True): """ Return the docstring for the given node or None if no docstring can be found. If the node provided does not have docstrings a TypeError will be raised. """ if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)): raise TypeError("%r can't have docstrings" % node.__class__.__name__) if not(node.body and isinstance(node.body[0], Expr)): return node = node.body[0].value if isinstance(node, Str): text = node.s elif isinstance(node, Constant) and isinstance(node.value, str): text = node.value else: return if clean: import inspect text = inspect.cleandoc(text) return text def walk(node): """ Recursively yield all descendant nodes in the tree starting at *node* (including *node* itself), in no specified order. This is useful if you only want to modify nodes in place and don't care about the context. """ from collections import deque todo = deque([node]) while todo: node = todo.popleft() todo.extend(iter_child_nodes(node)) yield node class NodeVisitor(object): """ A node visitor base class that walks the abstract syntax tree and calls a visitor function for every node found. This function may return a value which is forwarded by the `visit` method. This class is meant to be subclassed, with the subclass adding visitor methods. Per default the visitor functions for the nodes are ``'visit_'`` + class name of the node. So a `TryFinally` node visit function would be `visit_TryFinally`. This behavior can be changed by overriding the `visit` method. If no visitor function exists for a node (return value `None`) the `generic_visit` visitor is used instead. Don't use the `NodeVisitor` if you want to apply changes to nodes during traversing. For this a special visitor exists (`NodeTransformer`) that allows modifications. """ def visit(self, node): """Visit a node.""" method = 'visit_' + node.__class__.__name__ visitor = getattr(self, method, self.generic_visit) return visitor(node) def generic_visit(self, node): """Called if no explicit visitor function exists for a node.""" for field, value in iter_fields(node): if isinstance(value, list): for item in value: if isinstance(item, AST): self.visit(item) elif isinstance(value, AST): self.visit(value) class NodeTransformer(NodeVisitor): """ A :class:`NodeVisitor` subclass that walks the abstract syntax tree and allows modification of nodes. The `NodeTransformer` will walk the AST and use the return value of the visitor methods to replace or remove the old node. If the return value of the visitor method is ``None``, the node will be removed from its location, otherwise it is replaced with the return value. The return value may be the original node in which case no replacement takes place. Here is an example transformer that rewrites all occurrences of name lookups (``foo``) to ``data['foo']``:: class RewriteName(NodeTransformer): def visit_Name(self, node): return copy_location(Subscript( value=Name(id='data', ctx=Load()), slice=Index(value=Str(s=node.id)), ctx=node.ctx ), node) Keep in mind that if the node you're operating on has child nodes you must either transform the child nodes yourself or call the :meth:`generic_visit` method for the node first. For nodes that were part of a collection of statements (that applies to all statement nodes), the visitor may also return a list of nodes rather than just a single node. Usually you use the transformer like this:: node = YourTransformer().visit(node) """ def generic_visit(self, node): for field, old_value in iter_fields(node): if isinstance(old_value, list): new_values = [] for value in old_value: if isinstance(value, AST): value = self.visit(value) if value is None: continue elif not isinstance(value, AST): new_values.extend(value) continue new_values.append(value) old_value[:] = new_values elif isinstance(old_value, AST): new_node = self.visit(old_value) if new_node is None: delattr(node, field) else: setattr(node, field, new_node) return node typed-ast-1.1.0/typed_ast/conversions.py0000644€Tøžæ€2›s®0000002056413050216645021647 0ustar ddfisher00000000000000from typed_ast import ast27 from typed_ast import ast3 def py2to3(ast): """Converts a typed Python 2.7 ast to a typed Python 3.5 ast. The returned ast is a valid Python 3 ast with two exceptions: - `arg` objects may contain Tuple objects instead of just identifiers in the case of Python 2 function definitions/lambdas that use the tuple unpacking syntax. - `Raise` objects will have a `traceback` attribute added if the 3 argument version of the Python 2 raise is used. Strange and Rare Uncovered Edge Cases: - Raise: if the second argument to a raise statement is a tuple, its contents are unpacked as arguments to the exception constructor. This case is handled correctly if it's a literal tuple, but not if it's any other sort of tuple expression. """ return _AST2To3().visit(ast) def _copy_attributes(new_value, old_value): attrs = getattr(old_value, '_attributes', None) if attrs is not None: for attr in attrs: setattr(new_value, attr, getattr(old_value, attr)) return new_value class _AST2To3(ast27.NodeTransformer): # note: None, True, and False are *not* translated into NameConstants. def __init__(self): pass def visit(self, node): """Visit a node.""" method = 'visit_' + node.__class__.__name__ visitor = getattr(self, method, self.generic_visit) ret = _copy_attributes(visitor(node), node) return ret def maybe_visit(self, node): if node is not None: return self.visit(node) else: return None def generic_visit(self, node): class_name = node.__class__.__name__ converted_class = getattr(ast3, class_name) new_node = converted_class() for field, old_value in ast27.iter_fields(node): if isinstance(old_value, (ast27.AST, list)): setattr(new_node, field, self.visit(old_value)) else: setattr(new_node, field, old_value) return new_node def visit_list(self, l): return [self.visit(e) if isinstance(e, (ast27.AST, list)) else e for e in l] def visit_FunctionDef(self, n): new = self.generic_visit(n) new.returns = None return new def visit_ClassDef(self, n): new = self.generic_visit(n) new.keywords = [] return new def visit_TryExcept(self, n): return ast3.Try(self.visit(n.body), self.visit(n.handlers), self.visit(n.orelse), []) def visit_TryFinally(self, n): if len(n.body) == 1 and isinstance(n.body[0], ast27.TryExcept): new = self.visit(n.body[0]) new.finalbody = self.visit(n.finalbody) return new else: return ast3.Try(self.visit(n.body), [], [], self.visit(n.finalbody)) def visit_ExceptHandler(self, n): if n.name is None: name = None elif isinstance(n.name, ast27.Name): name = n.name.id else: raise RuntimeError("'{}' has non-Name name.".format(ast27.dump(n))) return ast3.ExceptHandler(self.maybe_visit(n.type), name, self.visit(n.body)) def visit_Print(self, n): keywords = [] if n.dest is not None: keywords.append(ast3.keyword("file", self.visit(n.dest))) if not n.nl: keywords.append(ast3.keyword("end", ast3.Str(" ", lineno=n.lineno, col_offset=-1))) return ast3.Expr(ast3.Call(ast3.Name("print", ast3.Load(), lineno=n.lineno, col_offset=-1), self.visit(n.values), keywords, lineno=n.lineno, col_offset=-1)) def visit_Raise(self, n): e = None if n.type is not None: e = self.visit(n.type) if n.inst is not None and not (isinstance(n.inst, ast27.Name) and n.inst.id == "None"): inst = self.visit(n.inst) if isinstance(inst, ast3.Tuple): args = inst.elts else: args = [inst] e = ast3.Call(e, args, [], lineno=e.lineno, col_offset=-1) ret = ast3.Raise(e, None) if n.tback is not None: ret.traceback = self.visit(n.tback) return ret def visit_Exec(self, n): new_globals = self.maybe_visit(n.globals) if new_globals is None: new_globals = ast3.Name("None", ast3.Load(), lineno=-1, col_offset=-1) new_locals = self.maybe_visit(n.locals) if new_locals is None: new_locals = ast3.Name("None", ast3.Load(), lineno=-1, col_offset=-1) return ast3.Expr(ast3.Call(ast3.Name("exec", ast3.Load(), lineno=n.lineno, col_offset=-1), [self.visit(n.body), new_globals, new_locals], [], lineno=n.lineno, col_offset=-1)) # TODO(ddfisher): the name repr could be used locally as something else; disambiguate def visit_Repr(self, n): return ast3.Call(ast3.Name("repr", ast3.Load(), lineno=n.lineno, col_offset=-1), [self.visit(n.value)], []) # TODO(ddfisher): this will cause strange behavior on multi-item with statements with type comments def visit_With(self, n): return ast3.With([ast3.withitem(self.visit(n.context_expr), self.maybe_visit(n.optional_vars))], self.visit(n.body), n.type_comment) def visit_Call(self, n): args = self.visit(n.args) if n.starargs is not None: args.append(ast3.Starred(self.visit(n.starargs), ast3.Load(), lineno=n.starargs.lineno, col_offset=n.starargs.col_offset)) keywords = self.visit(n.keywords) if n.kwargs is not None: keywords.append(ast3.keyword(None, self.visit(n.kwargs))) return ast3.Call(self.visit(n.func), args, keywords) # TODO(ddfisher): find better attributes to give Ellipses def visit_Ellipsis(self, n): # ellipses in Python 2 only exist as a slice index return ast3.Index(ast3.Ellipsis(lineno=-1, col_offset=-1)) def visit_arguments(self, n): def convert_arg(arg, type_comment): if isinstance(arg, ast27.Name): v = arg.id elif isinstance(arg, ast27.Tuple): v = self.visit(arg) else: raise RuntimeError("'{}' is not a valid argument.".format(ast27.dump(arg))) return ast3.arg(v, None, type_comment, lineno=arg.lineno, col_offset=arg.col_offset) def get_type_comment(i): if i < len(n.type_comments) and n.type_comments[i] is not None: return n.type_comments[i] return None args = [convert_arg(arg, get_type_comment(i)) for i, arg in enumerate(n.args)] vararg = None if n.vararg is not None: vararg = ast3.arg(n.vararg, None, get_type_comment(len(args)), lineno=-1, col_offset=-1) kwarg = None if n.kwarg is not None: kwarg = ast3.arg(n.kwarg, None, get_type_comment(len(args) + (0 if n.vararg is None else 1)), lineno=-1, col_offset=-1) defaults = self.visit(n.defaults) return ast3.arguments(args, vararg, [], [], kwarg, defaults) def visit_Str(self, s): if isinstance(s.s, bytes): return ast3.Bytes(s.s) else: return ast3.Str(s.s) def visit_Num(self, n): new = self.generic_visit(n) if new.n < 0: # Python 3 uses a unary - operator for negative literals. new.n = -new.n return ast3.UnaryOp(op=ast3.USub(), operand=_copy_attributes(new, n)) else: return new typed-ast-1.1.0/typed_ast.egg-info/0000755€Tøžæ€2›s®0000000000013133476735020422 5ustar ddfisher00000000000000typed-ast-1.1.0/typed_ast.egg-info/dependency_links.txt0000644€Tøžæ€2›s®0000000000113133476735024470 0ustar ddfisher00000000000000 typed-ast-1.1.0/typed_ast.egg-info/PKG-INFO0000644€Tøžæ€2›s®0000000231313133476735021516 0ustar ddfisher00000000000000Metadata-Version: 1.1 Name: typed-ast Version: 1.1.0 Summary: a fork of Python 2 and 3 ast modules with type comment support Home-page: https://github.com/python/typed_ast Author: David Fisher Author-email: ddfisher@dropbox.com License: Apache License 2.0 Description: `typed_ast` is a Python 3 package that provides a Python 2.7 and Python 3 parser similar to the standard `ast` library. Unlike `ast`, the parsers in `typed_ast` include PEP 484 type comments and are independent of the version of Python under which they are run. The `typed_ast` parsers produce the standard Python AST (plus type comments), and are both fast and correct, as they are based on the CPython 2.7 and 3.6 parsers. Platform: POSIX Platform: Windows Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: Operating System :: POSIX Classifier: Operating System :: Microsoft Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Topic :: Software Development typed-ast-1.1.0/typed_ast.egg-info/SOURCES.txt0000644€Tøžæ€2›s®0000000264313133476735022313 0ustar ddfisher00000000000000LICENSE MANIFEST.in setup.py ast27/Custom/typed_ast.c ast27/Include/Python-ast.h ast27/Include/asdl.h ast27/Include/ast.h ast27/Include/bitset.h ast27/Include/compile.h ast27/Include/errcode.h ast27/Include/graminit.h ast27/Include/grammar.h ast27/Include/node.h ast27/Include/parsetok.h ast27/Include/token.h ast27/Parser/acceler.c ast27/Parser/bitset.c ast27/Parser/grammar.c ast27/Parser/grammar1.c ast27/Parser/node.c ast27/Parser/parser.c ast27/Parser/parser.h ast27/Parser/parsetok.c ast27/Parser/tokenizer.c ast27/Parser/tokenizer.h ast27/Python/Python-ast.c ast27/Python/asdl.c ast27/Python/ast.c ast27/Python/graminit.c ast27/Python/mystrtoul.c ast3/Custom/typed_ast.c ast3/Include/Python-ast.h ast3/Include/asdl.h ast3/Include/ast.h ast3/Include/bitset.h ast3/Include/compile.h ast3/Include/errcode.h ast3/Include/graminit.h ast3/Include/grammar.h ast3/Include/node.h ast3/Include/parsetok.h ast3/Include/token.h ast3/Parser/acceler.c ast3/Parser/bitset.c ast3/Parser/grammar.c ast3/Parser/grammar1.c ast3/Parser/node.c ast3/Parser/parser.c ast3/Parser/parser.h ast3/Parser/parsetok.c ast3/Parser/tokenizer.c ast3/Parser/tokenizer.h ast3/Python/Python-ast.c ast3/Python/asdl.c ast3/Python/ast.c ast3/Python/graminit.c typed_ast/__init__.py typed_ast/ast27.py typed_ast/ast3.py typed_ast/conversions.py typed_ast.egg-info/PKG-INFO typed_ast.egg-info/SOURCES.txt typed_ast.egg-info/dependency_links.txt typed_ast.egg-info/top_level.txttyped-ast-1.1.0/typed_ast.egg-info/top_level.txt0000644€Tøžæ€2›s®0000000002713133476735023153 0ustar ddfisher00000000000000_ast27 _ast3 typed_ast