Jeremy Hylton | 3e0055f | 2005-10-20 19:59:25 +0000 | [diff] [blame] | 1 | /* |
Batuhan Taskaya | 02a1603 | 2020-10-10 20:14:59 +0300 | [diff] [blame] | 2 | * This file exposes PyAST_Validate interface to check the integrity |
| 3 | * of the given abstract syntax tree (potentially constructed manually). |
Jeremy Hylton | 3e0055f | 2005-10-20 19:59:25 +0000 | [diff] [blame] | 4 | */ |
| 5 | #include "Python.h" |
| 6 | #include "Python-ast.h" |
Jeremy Hylton | 3e0055f | 2005-10-20 19:59:25 +0000 | [diff] [blame] | 7 | #include "ast.h" |
Jeremy Hylton | 3e0055f | 2005-10-20 19:59:25 +0000 | [diff] [blame] | 8 | |
| 9 | #include <assert.h> |
Serhiy Storchaka | 58159ef | 2019-01-12 09:46:50 +0200 | [diff] [blame] | 10 | |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 11 | static int validate_stmts(asdl_stmt_seq *); |
| 12 | static int validate_exprs(asdl_expr_seq*, expr_context_ty, int); |
| 13 | static int _validate_nonempty_seq(asdl_seq *, const char *, const char *); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 14 | static int validate_stmt(stmt_ty); |
| 15 | static int validate_expr(expr_ty, expr_context_ty); |
| 16 | |
| 17 | static int |
Batuhan Taskaya | 68874a8 | 2020-06-06 15:44:16 +0300 | [diff] [blame] | 18 | validate_name(PyObject *name) |
| 19 | { |
| 20 | assert(PyUnicode_Check(name)); |
| 21 | static const char * const forbidden[] = { |
| 22 | "None", |
| 23 | "True", |
| 24 | "False", |
| 25 | NULL |
| 26 | }; |
| 27 | for (int i = 0; forbidden[i] != NULL; i++) { |
| 28 | if (_PyUnicode_EqualToASCIIString(name, forbidden[i])) { |
| 29 | PyErr_Format(PyExc_ValueError, "Name node can't be used with '%s' constant", forbidden[i]); |
| 30 | return 0; |
| 31 | } |
| 32 | } |
| 33 | return 1; |
| 34 | } |
| 35 | |
| 36 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 37 | validate_comprehension(asdl_comprehension_seq *gens) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 38 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 39 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 40 | if (!asdl_seq_LEN(gens)) { |
| 41 | PyErr_SetString(PyExc_ValueError, "comprehension with no generators"); |
| 42 | return 0; |
| 43 | } |
| 44 | for (i = 0; i < asdl_seq_LEN(gens); i++) { |
| 45 | comprehension_ty comp = asdl_seq_GET(gens, i); |
| 46 | if (!validate_expr(comp->target, Store) || |
| 47 | !validate_expr(comp->iter, Load) || |
| 48 | !validate_exprs(comp->ifs, Load, 0)) |
| 49 | return 0; |
| 50 | } |
| 51 | return 1; |
| 52 | } |
| 53 | |
| 54 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 55 | validate_keywords(asdl_keyword_seq *keywords) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 56 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 57 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 58 | for (i = 0; i < asdl_seq_LEN(keywords); i++) |
Batuhan Taskaya | 02a1603 | 2020-10-10 20:14:59 +0300 | [diff] [blame] | 59 | if (!validate_expr((asdl_seq_GET(keywords, i))->value, Load)) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 60 | return 0; |
| 61 | return 1; |
| 62 | } |
| 63 | |
| 64 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 65 | validate_args(asdl_arg_seq *args) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 66 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 67 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 68 | for (i = 0; i < asdl_seq_LEN(args); i++) { |
| 69 | arg_ty arg = asdl_seq_GET(args, i); |
| 70 | if (arg->annotation && !validate_expr(arg->annotation, Load)) |
| 71 | return 0; |
| 72 | } |
| 73 | return 1; |
| 74 | } |
| 75 | |
| 76 | static const char * |
| 77 | expr_context_name(expr_context_ty ctx) |
| 78 | { |
| 79 | switch (ctx) { |
| 80 | case Load: |
| 81 | return "Load"; |
| 82 | case Store: |
| 83 | return "Store"; |
| 84 | case Del: |
| 85 | return "Del"; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 86 | default: |
Barry Warsaw | b2e5794 | 2017-09-14 18:13:16 -0700 | [diff] [blame] | 87 | Py_UNREACHABLE(); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 88 | } |
| 89 | } |
| 90 | |
| 91 | static int |
| 92 | validate_arguments(arguments_ty args) |
| 93 | { |
Pablo Galindo | 8c77b8c | 2019-04-29 13:36:57 +0100 | [diff] [blame] | 94 | if (!validate_args(args->posonlyargs) || !validate_args(args->args)) { |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 95 | return 0; |
Pablo Galindo | 8c77b8c | 2019-04-29 13:36:57 +0100 | [diff] [blame] | 96 | } |
Benjamin Peterson | cda75be | 2013-03-18 10:48:58 -0700 | [diff] [blame] | 97 | if (args->vararg && args->vararg->annotation |
| 98 | && !validate_expr(args->vararg->annotation, Load)) { |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 99 | return 0; |
| 100 | } |
| 101 | if (!validate_args(args->kwonlyargs)) |
| 102 | return 0; |
Victor Stinner | 0c39b1b | 2015-03-18 15:02:06 +0100 | [diff] [blame] | 103 | if (args->kwarg && args->kwarg->annotation |
Benjamin Peterson | cda75be | 2013-03-18 10:48:58 -0700 | [diff] [blame] | 104 | && !validate_expr(args->kwarg->annotation, Load)) { |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 105 | return 0; |
| 106 | } |
Pablo Galindo | 2f58a84 | 2019-05-31 14:09:49 +0100 | [diff] [blame] | 107 | if (asdl_seq_LEN(args->defaults) > asdl_seq_LEN(args->posonlyargs) + asdl_seq_LEN(args->args)) { |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 108 | PyErr_SetString(PyExc_ValueError, "more positional defaults than args on arguments"); |
| 109 | return 0; |
| 110 | } |
| 111 | if (asdl_seq_LEN(args->kw_defaults) != asdl_seq_LEN(args->kwonlyargs)) { |
| 112 | PyErr_SetString(PyExc_ValueError, "length of kwonlyargs is not the same as " |
| 113 | "kw_defaults on arguments"); |
| 114 | return 0; |
| 115 | } |
| 116 | return validate_exprs(args->defaults, Load, 0) && validate_exprs(args->kw_defaults, Load, 1); |
| 117 | } |
| 118 | |
| 119 | static int |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 120 | validate_constant(PyObject *value) |
| 121 | { |
| 122 | if (value == Py_None || value == Py_Ellipsis) |
| 123 | return 1; |
| 124 | |
| 125 | if (PyLong_CheckExact(value) |
| 126 | || PyFloat_CheckExact(value) |
| 127 | || PyComplex_CheckExact(value) |
| 128 | || PyBool_Check(value) |
| 129 | || PyUnicode_CheckExact(value) |
| 130 | || PyBytes_CheckExact(value)) |
| 131 | return 1; |
| 132 | |
| 133 | if (PyTuple_CheckExact(value) || PyFrozenSet_CheckExact(value)) { |
| 134 | PyObject *it; |
| 135 | |
| 136 | it = PyObject_GetIter(value); |
| 137 | if (it == NULL) |
| 138 | return 0; |
| 139 | |
| 140 | while (1) { |
| 141 | PyObject *item = PyIter_Next(it); |
| 142 | if (item == NULL) { |
| 143 | if (PyErr_Occurred()) { |
| 144 | Py_DECREF(it); |
| 145 | return 0; |
| 146 | } |
| 147 | break; |
| 148 | } |
| 149 | |
| 150 | if (!validate_constant(item)) { |
| 151 | Py_DECREF(it); |
Victor Stinner | 726f690 | 2016-01-27 00:11:47 +0100 | [diff] [blame] | 152 | Py_DECREF(item); |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 153 | return 0; |
| 154 | } |
Victor Stinner | 726f690 | 2016-01-27 00:11:47 +0100 | [diff] [blame] | 155 | Py_DECREF(item); |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | Py_DECREF(it); |
| 159 | return 1; |
| 160 | } |
| 161 | |
Batuhan TaÅŸkaya | 0ac59f9 | 2020-03-19 14:32:28 +0300 | [diff] [blame] | 162 | if (!PyErr_Occurred()) { |
| 163 | PyErr_Format(PyExc_TypeError, |
| 164 | "got an invalid type in Constant: %s", |
| 165 | _PyType_Name(Py_TYPE(value))); |
| 166 | } |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 167 | return 0; |
| 168 | } |
| 169 | |
| 170 | static int |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 171 | validate_expr(expr_ty exp, expr_context_ty ctx) |
| 172 | { |
| 173 | int check_ctx = 1; |
| 174 | expr_context_ty actual_ctx; |
| 175 | |
| 176 | /* First check expression context. */ |
| 177 | switch (exp->kind) { |
| 178 | case Attribute_kind: |
| 179 | actual_ctx = exp->v.Attribute.ctx; |
| 180 | break; |
| 181 | case Subscript_kind: |
| 182 | actual_ctx = exp->v.Subscript.ctx; |
| 183 | break; |
| 184 | case Starred_kind: |
| 185 | actual_ctx = exp->v.Starred.ctx; |
| 186 | break; |
| 187 | case Name_kind: |
Batuhan Taskaya | 68874a8 | 2020-06-06 15:44:16 +0300 | [diff] [blame] | 188 | if (!validate_name(exp->v.Name.id)) { |
| 189 | return 0; |
| 190 | } |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 191 | actual_ctx = exp->v.Name.ctx; |
| 192 | break; |
| 193 | case List_kind: |
| 194 | actual_ctx = exp->v.List.ctx; |
| 195 | break; |
| 196 | case Tuple_kind: |
| 197 | actual_ctx = exp->v.Tuple.ctx; |
| 198 | break; |
| 199 | default: |
| 200 | if (ctx != Load) { |
| 201 | PyErr_Format(PyExc_ValueError, "expression which can't be " |
| 202 | "assigned to in %s context", expr_context_name(ctx)); |
| 203 | return 0; |
| 204 | } |
| 205 | check_ctx = 0; |
Victor Stinner | 0c39b1b | 2015-03-18 15:02:06 +0100 | [diff] [blame] | 206 | /* set actual_ctx to prevent gcc warning */ |
| 207 | actual_ctx = 0; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 208 | } |
| 209 | if (check_ctx && actual_ctx != ctx) { |
| 210 | PyErr_Format(PyExc_ValueError, "expression must have %s context but has %s instead", |
| 211 | expr_context_name(ctx), expr_context_name(actual_ctx)); |
| 212 | return 0; |
| 213 | } |
| 214 | |
| 215 | /* Now validate expression. */ |
| 216 | switch (exp->kind) { |
| 217 | case BoolOp_kind: |
| 218 | if (asdl_seq_LEN(exp->v.BoolOp.values) < 2) { |
| 219 | PyErr_SetString(PyExc_ValueError, "BoolOp with less than 2 values"); |
| 220 | return 0; |
| 221 | } |
| 222 | return validate_exprs(exp->v.BoolOp.values, Load, 0); |
| 223 | case BinOp_kind: |
| 224 | return validate_expr(exp->v.BinOp.left, Load) && |
| 225 | validate_expr(exp->v.BinOp.right, Load); |
| 226 | case UnaryOp_kind: |
| 227 | return validate_expr(exp->v.UnaryOp.operand, Load); |
| 228 | case Lambda_kind: |
| 229 | return validate_arguments(exp->v.Lambda.args) && |
| 230 | validate_expr(exp->v.Lambda.body, Load); |
| 231 | case IfExp_kind: |
| 232 | return validate_expr(exp->v.IfExp.test, Load) && |
| 233 | validate_expr(exp->v.IfExp.body, Load) && |
| 234 | validate_expr(exp->v.IfExp.orelse, Load); |
| 235 | case Dict_kind: |
| 236 | if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) { |
| 237 | PyErr_SetString(PyExc_ValueError, |
| 238 | "Dict doesn't have the same number of keys as values"); |
| 239 | return 0; |
| 240 | } |
Yury Selivanov | b3d5313 | 2015-09-01 16:10:49 -0400 | [diff] [blame] | 241 | /* null_ok=1 for keys expressions to allow dict unpacking to work in |
| 242 | dict literals, i.e. ``{**{a:b}}`` */ |
| 243 | return validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) && |
| 244 | validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 245 | case Set_kind: |
| 246 | return validate_exprs(exp->v.Set.elts, Load, 0); |
| 247 | #define COMP(NAME) \ |
| 248 | case NAME ## _kind: \ |
| 249 | return validate_comprehension(exp->v.NAME.generators) && \ |
| 250 | validate_expr(exp->v.NAME.elt, Load); |
| 251 | COMP(ListComp) |
| 252 | COMP(SetComp) |
| 253 | COMP(GeneratorExp) |
| 254 | #undef COMP |
| 255 | case DictComp_kind: |
| 256 | return validate_comprehension(exp->v.DictComp.generators) && |
| 257 | validate_expr(exp->v.DictComp.key, Load) && |
| 258 | validate_expr(exp->v.DictComp.value, Load); |
| 259 | case Yield_kind: |
| 260 | return !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load); |
Benjamin Peterson | 527c622 | 2012-01-14 08:58:23 -0500 | [diff] [blame] | 261 | case YieldFrom_kind: |
Mark Dickinson | ded35ae | 2012-11-25 14:36:26 +0000 | [diff] [blame] | 262 | return validate_expr(exp->v.YieldFrom.value, Load); |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 263 | case Await_kind: |
| 264 | return validate_expr(exp->v.Await.value, Load); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 265 | case Compare_kind: |
| 266 | if (!asdl_seq_LEN(exp->v.Compare.comparators)) { |
| 267 | PyErr_SetString(PyExc_ValueError, "Compare with no comparators"); |
| 268 | return 0; |
| 269 | } |
| 270 | if (asdl_seq_LEN(exp->v.Compare.comparators) != |
| 271 | asdl_seq_LEN(exp->v.Compare.ops)) { |
| 272 | PyErr_SetString(PyExc_ValueError, "Compare has a different number " |
| 273 | "of comparators and operands"); |
| 274 | return 0; |
| 275 | } |
| 276 | return validate_exprs(exp->v.Compare.comparators, Load, 0) && |
| 277 | validate_expr(exp->v.Compare.left, Load); |
| 278 | case Call_kind: |
| 279 | return validate_expr(exp->v.Call.func, Load) && |
| 280 | validate_exprs(exp->v.Call.args, Load, 0) && |
Benjamin Peterson | 025e9eb | 2015-05-05 20:16:41 -0400 | [diff] [blame] | 281 | validate_keywords(exp->v.Call.keywords); |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 282 | case Constant_kind: |
| 283 | if (!validate_constant(exp->v.Constant.value)) { |
Victor Stinner | f2c1aa1 | 2016-01-26 00:40:57 +0100 | [diff] [blame] | 284 | return 0; |
| 285 | } |
| 286 | return 1; |
Eric V. Smith | 235a6f0 | 2015-09-19 14:51:32 -0400 | [diff] [blame] | 287 | case JoinedStr_kind: |
| 288 | return validate_exprs(exp->v.JoinedStr.values, Load, 0); |
| 289 | case FormattedValue_kind: |
| 290 | if (validate_expr(exp->v.FormattedValue.value, Load) == 0) |
| 291 | return 0; |
| 292 | if (exp->v.FormattedValue.format_spec) |
| 293 | return validate_expr(exp->v.FormattedValue.format_spec, Load); |
| 294 | return 1; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 295 | case Attribute_kind: |
| 296 | return validate_expr(exp->v.Attribute.value, Load); |
| 297 | case Subscript_kind: |
Serhiy Storchaka | 13d52c2 | 2020-03-10 18:52:34 +0200 | [diff] [blame] | 298 | return validate_expr(exp->v.Subscript.slice, Load) && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 299 | validate_expr(exp->v.Subscript.value, Load); |
| 300 | case Starred_kind: |
| 301 | return validate_expr(exp->v.Starred.value, ctx); |
Serhiy Storchaka | 13d52c2 | 2020-03-10 18:52:34 +0200 | [diff] [blame] | 302 | case Slice_kind: |
| 303 | return (!exp->v.Slice.lower || validate_expr(exp->v.Slice.lower, Load)) && |
| 304 | (!exp->v.Slice.upper || validate_expr(exp->v.Slice.upper, Load)) && |
| 305 | (!exp->v.Slice.step || validate_expr(exp->v.Slice.step, Load)); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 306 | case List_kind: |
| 307 | return validate_exprs(exp->v.List.elts, ctx, 0); |
| 308 | case Tuple_kind: |
| 309 | return validate_exprs(exp->v.Tuple.elts, ctx, 0); |
Pablo Galindo | 0c9258a | 2019-03-18 13:51:53 +0000 | [diff] [blame] | 310 | case NamedExpr_kind: |
| 311 | return validate_expr(exp->v.NamedExpr.value, Load); |
Serhiy Storchaka | 3f22811 | 2018-09-27 17:42:37 +0300 | [diff] [blame] | 312 | /* This last case doesn't have any checking. */ |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 313 | case Name_kind: |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 314 | return 1; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 315 | } |
Pablo Galindo | 0c9258a | 2019-03-18 13:51:53 +0000 | [diff] [blame] | 316 | PyErr_SetString(PyExc_SystemError, "unexpected expression"); |
| 317 | return 0; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 318 | } |
| 319 | |
| 320 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 321 | _validate_nonempty_seq(asdl_seq *seq, const char *what, const char *owner) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 322 | { |
| 323 | if (asdl_seq_LEN(seq)) |
| 324 | return 1; |
| 325 | PyErr_Format(PyExc_ValueError, "empty %s on %s", what, owner); |
| 326 | return 0; |
| 327 | } |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 328 | #define validate_nonempty_seq(seq, what, owner) _validate_nonempty_seq((asdl_seq*)seq, what, owner) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 329 | |
| 330 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 331 | validate_assignlist(asdl_expr_seq *targets, expr_context_ty ctx) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 332 | { |
| 333 | return validate_nonempty_seq(targets, "targets", ctx == Del ? "Delete" : "Assign") && |
| 334 | validate_exprs(targets, ctx, 0); |
| 335 | } |
| 336 | |
| 337 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 338 | validate_body(asdl_stmt_seq *body, const char *owner) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 339 | { |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 340 | return validate_nonempty_seq(body, "body", owner) && validate_stmts(body); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | static int |
| 344 | validate_stmt(stmt_ty stmt) |
| 345 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 346 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 347 | switch (stmt->kind) { |
| 348 | case FunctionDef_kind: |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 349 | return validate_body(stmt->v.FunctionDef.body, "FunctionDef") && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 350 | validate_arguments(stmt->v.FunctionDef.args) && |
| 351 | validate_exprs(stmt->v.FunctionDef.decorator_list, Load, 0) && |
| 352 | (!stmt->v.FunctionDef.returns || |
| 353 | validate_expr(stmt->v.FunctionDef.returns, Load)); |
| 354 | case ClassDef_kind: |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 355 | return validate_body(stmt->v.ClassDef.body, "ClassDef") && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 356 | validate_exprs(stmt->v.ClassDef.bases, Load, 0) && |
| 357 | validate_keywords(stmt->v.ClassDef.keywords) && |
Benjamin Peterson | 025e9eb | 2015-05-05 20:16:41 -0400 | [diff] [blame] | 358 | validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 359 | case Return_kind: |
| 360 | return !stmt->v.Return.value || validate_expr(stmt->v.Return.value, Load); |
| 361 | case Delete_kind: |
| 362 | return validate_assignlist(stmt->v.Delete.targets, Del); |
| 363 | case Assign_kind: |
| 364 | return validate_assignlist(stmt->v.Assign.targets, Store) && |
| 365 | validate_expr(stmt->v.Assign.value, Load); |
| 366 | case AugAssign_kind: |
| 367 | return validate_expr(stmt->v.AugAssign.target, Store) && |
| 368 | validate_expr(stmt->v.AugAssign.value, Load); |
Yury Selivanov | f8cb8a1 | 2016-09-08 20:50:03 -0700 | [diff] [blame] | 369 | case AnnAssign_kind: |
| 370 | if (stmt->v.AnnAssign.target->kind != Name_kind && |
| 371 | stmt->v.AnnAssign.simple) { |
| 372 | PyErr_SetString(PyExc_TypeError, |
| 373 | "AnnAssign with simple non-Name target"); |
| 374 | return 0; |
| 375 | } |
| 376 | return validate_expr(stmt->v.AnnAssign.target, Store) && |
| 377 | (!stmt->v.AnnAssign.value || |
| 378 | validate_expr(stmt->v.AnnAssign.value, Load)) && |
| 379 | validate_expr(stmt->v.AnnAssign.annotation, Load); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 380 | case For_kind: |
| 381 | return validate_expr(stmt->v.For.target, Store) && |
| 382 | validate_expr(stmt->v.For.iter, Load) && |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 383 | validate_body(stmt->v.For.body, "For") && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 384 | validate_stmts(stmt->v.For.orelse); |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 385 | case AsyncFor_kind: |
| 386 | return validate_expr(stmt->v.AsyncFor.target, Store) && |
| 387 | validate_expr(stmt->v.AsyncFor.iter, Load) && |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 388 | validate_body(stmt->v.AsyncFor.body, "AsyncFor") && |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 389 | validate_stmts(stmt->v.AsyncFor.orelse); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 390 | case While_kind: |
| 391 | return validate_expr(stmt->v.While.test, Load) && |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 392 | validate_body(stmt->v.While.body, "While") && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 393 | validate_stmts(stmt->v.While.orelse); |
| 394 | case If_kind: |
| 395 | return validate_expr(stmt->v.If.test, Load) && |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 396 | validate_body(stmt->v.If.body, "If") && |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 397 | validate_stmts(stmt->v.If.orelse); |
| 398 | case With_kind: |
| 399 | if (!validate_nonempty_seq(stmt->v.With.items, "items", "With")) |
| 400 | return 0; |
| 401 | for (i = 0; i < asdl_seq_LEN(stmt->v.With.items); i++) { |
| 402 | withitem_ty item = asdl_seq_GET(stmt->v.With.items, i); |
| 403 | if (!validate_expr(item->context_expr, Load) || |
| 404 | (item->optional_vars && !validate_expr(item->optional_vars, Store))) |
| 405 | return 0; |
| 406 | } |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 407 | return validate_body(stmt->v.With.body, "With"); |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 408 | case AsyncWith_kind: |
| 409 | if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith")) |
| 410 | return 0; |
| 411 | for (i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) { |
| 412 | withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i); |
| 413 | if (!validate_expr(item->context_expr, Load) || |
| 414 | (item->optional_vars && !validate_expr(item->optional_vars, Store))) |
| 415 | return 0; |
| 416 | } |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 417 | return validate_body(stmt->v.AsyncWith.body, "AsyncWith"); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 418 | case Raise_kind: |
| 419 | if (stmt->v.Raise.exc) { |
| 420 | return validate_expr(stmt->v.Raise.exc, Load) && |
| 421 | (!stmt->v.Raise.cause || validate_expr(stmt->v.Raise.cause, Load)); |
| 422 | } |
| 423 | if (stmt->v.Raise.cause) { |
| 424 | PyErr_SetString(PyExc_ValueError, "Raise with cause but no exception"); |
| 425 | return 0; |
| 426 | } |
| 427 | return 1; |
| 428 | case Try_kind: |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 429 | if (!validate_body(stmt->v.Try.body, "Try")) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 430 | return 0; |
| 431 | if (!asdl_seq_LEN(stmt->v.Try.handlers) && |
| 432 | !asdl_seq_LEN(stmt->v.Try.finalbody)) { |
| 433 | PyErr_SetString(PyExc_ValueError, "Try has neither except handlers nor finalbody"); |
| 434 | return 0; |
| 435 | } |
| 436 | if (!asdl_seq_LEN(stmt->v.Try.handlers) && |
| 437 | asdl_seq_LEN(stmt->v.Try.orelse)) { |
| 438 | PyErr_SetString(PyExc_ValueError, "Try has orelse but no except handlers"); |
| 439 | return 0; |
| 440 | } |
| 441 | for (i = 0; i < asdl_seq_LEN(stmt->v.Try.handlers); i++) { |
| 442 | excepthandler_ty handler = asdl_seq_GET(stmt->v.Try.handlers, i); |
| 443 | if ((handler->v.ExceptHandler.type && |
| 444 | !validate_expr(handler->v.ExceptHandler.type, Load)) || |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 445 | !validate_body(handler->v.ExceptHandler.body, "ExceptHandler")) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 446 | return 0; |
| 447 | } |
| 448 | return (!asdl_seq_LEN(stmt->v.Try.finalbody) || |
| 449 | validate_stmts(stmt->v.Try.finalbody)) && |
| 450 | (!asdl_seq_LEN(stmt->v.Try.orelse) || |
| 451 | validate_stmts(stmt->v.Try.orelse)); |
| 452 | case Assert_kind: |
| 453 | return validate_expr(stmt->v.Assert.test, Load) && |
| 454 | (!stmt->v.Assert.msg || validate_expr(stmt->v.Assert.msg, Load)); |
| 455 | case Import_kind: |
| 456 | return validate_nonempty_seq(stmt->v.Import.names, "names", "Import"); |
| 457 | case ImportFrom_kind: |
Serhiy Storchaka | fbd1523 | 2016-06-27 21:39:12 +0300 | [diff] [blame] | 458 | if (stmt->v.ImportFrom.level < 0) { |
| 459 | PyErr_SetString(PyExc_ValueError, "Negative ImportFrom level"); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 460 | return 0; |
| 461 | } |
| 462 | return validate_nonempty_seq(stmt->v.ImportFrom.names, "names", "ImportFrom"); |
| 463 | case Global_kind: |
| 464 | return validate_nonempty_seq(stmt->v.Global.names, "names", "Global"); |
| 465 | case Nonlocal_kind: |
| 466 | return validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal"); |
| 467 | case Expr_kind: |
| 468 | return validate_expr(stmt->v.Expr.value, Load); |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 469 | case AsyncFunctionDef_kind: |
Serhiy Storchaka | 73cbe7a | 2018-05-29 12:04:55 +0300 | [diff] [blame] | 470 | return validate_body(stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") && |
Yury Selivanov | 7544508 | 2015-05-11 22:57:16 -0400 | [diff] [blame] | 471 | validate_arguments(stmt->v.AsyncFunctionDef.args) && |
| 472 | validate_exprs(stmt->v.AsyncFunctionDef.decorator_list, Load, 0) && |
| 473 | (!stmt->v.AsyncFunctionDef.returns || |
| 474 | validate_expr(stmt->v.AsyncFunctionDef.returns, Load)); |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 475 | case Pass_kind: |
| 476 | case Break_kind: |
| 477 | case Continue_kind: |
| 478 | return 1; |
| 479 | default: |
| 480 | PyErr_SetString(PyExc_SystemError, "unexpected statement"); |
| 481 | return 0; |
| 482 | } |
| 483 | } |
| 484 | |
| 485 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 486 | validate_stmts(asdl_stmt_seq *seq) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 487 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 488 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 489 | for (i = 0; i < asdl_seq_LEN(seq); i++) { |
| 490 | stmt_ty stmt = asdl_seq_GET(seq, i); |
| 491 | if (stmt) { |
| 492 | if (!validate_stmt(stmt)) |
| 493 | return 0; |
| 494 | } |
| 495 | else { |
| 496 | PyErr_SetString(PyExc_ValueError, |
| 497 | "None disallowed in statement list"); |
| 498 | return 0; |
| 499 | } |
| 500 | } |
| 501 | return 1; |
| 502 | } |
| 503 | |
| 504 | static int |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 505 | validate_exprs(asdl_expr_seq *exprs, expr_context_ty ctx, int null_ok) |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 506 | { |
Victor Stinner | 4d73ae7 | 2018-11-22 14:45:16 +0100 | [diff] [blame] | 507 | Py_ssize_t i; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 508 | for (i = 0; i < asdl_seq_LEN(exprs); i++) { |
| 509 | expr_ty expr = asdl_seq_GET(exprs, i); |
| 510 | if (expr) { |
| 511 | if (!validate_expr(expr, ctx)) |
| 512 | return 0; |
| 513 | } |
| 514 | else if (!null_ok) { |
| 515 | PyErr_SetString(PyExc_ValueError, |
| 516 | "None disallowed in expression list"); |
| 517 | return 0; |
| 518 | } |
Victor Stinner | 0c39b1b | 2015-03-18 15:02:06 +0100 | [diff] [blame] | 519 | |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 520 | } |
| 521 | return 1; |
| 522 | } |
| 523 | |
| 524 | int |
| 525 | PyAST_Validate(mod_ty mod) |
| 526 | { |
| 527 | int res = 0; |
| 528 | |
| 529 | switch (mod->kind) { |
| 530 | case Module_kind: |
| 531 | res = validate_stmts(mod->v.Module.body); |
| 532 | break; |
| 533 | case Interactive_kind: |
| 534 | res = validate_stmts(mod->v.Interactive.body); |
| 535 | break; |
| 536 | case Expression_kind: |
| 537 | res = validate_expr(mod->v.Expression.body, Load); |
| 538 | break; |
Benjamin Peterson | 832bfe2 | 2011-08-09 16:15:04 -0500 | [diff] [blame] | 539 | default: |
| 540 | PyErr_SetString(PyExc_SystemError, "impossible module node"); |
| 541 | res = 0; |
| 542 | break; |
| 543 | } |
| 544 | return res; |
| 545 | } |
| 546 | |
Serhiy Storchaka | 143ce5c | 2018-05-30 10:56:16 +0300 | [diff] [blame] | 547 | PyObject * |
Pablo Galindo | a5634c4 | 2020-09-16 19:42:00 +0100 | [diff] [blame] | 548 | _PyAST_GetDocString(asdl_stmt_seq *body) |
Serhiy Storchaka | 143ce5c | 2018-05-30 10:56:16 +0300 | [diff] [blame] | 549 | { |
| 550 | if (!asdl_seq_LEN(body)) { |
| 551 | return NULL; |
| 552 | } |
Batuhan Taskaya | 02a1603 | 2020-10-10 20:14:59 +0300 | [diff] [blame] | 553 | stmt_ty st = asdl_seq_GET(body, 0); |
Serhiy Storchaka | 143ce5c | 2018-05-30 10:56:16 +0300 | [diff] [blame] | 554 | if (st->kind != Expr_kind) { |
| 555 | return NULL; |
| 556 | } |
| 557 | expr_ty e = st->v.Expr.value; |
Serhiy Storchaka | 143ce5c | 2018-05-30 10:56:16 +0300 | [diff] [blame] | 558 | if (e->kind == Constant_kind && PyUnicode_CheckExact(e->v.Constant.value)) { |
| 559 | return e->v.Constant.value; |
| 560 | } |
| 561 | return NULL; |
| 562 | } |