Lines Matching defs:state

67 validate_comprehension(struct validator *state, asdl_comprehension_seq *gens)
76 if (!validate_expr(state, comp->target, Store) ||
77 !validate_expr(state, comp->iter, Load) ||
78 !validate_exprs(state, comp->ifs, Load, 0))
85 validate_keywords(struct validator *state, asdl_keyword_seq *keywords)
89 if (!validate_expr(state, (asdl_seq_GET(keywords, i))->value, Load))
95 validate_args(struct validator *state, asdl_arg_seq *args)
101 if (arg->annotation && !validate_expr(state, arg->annotation, Load))
123 validate_arguments(struct validator *state, arguments_ty args)
126 if (!validate_args(state, args->posonlyargs) || !validate_args(state, args->args)) {
130 && !validate_expr(state, args->vararg->annotation, Load)) {
133 if (!validate_args(state, args->kwonlyargs))
136 && !validate_expr(state, args->kwarg->annotation, Load)) {
148 return validate_exprs(state, args->defaults, Load, 0) && validate_exprs(state, args->kw_defaults, Load, 1);
152 validate_constant(struct validator *state, PyObject *value)
167 if (++state->recursion_depth > state->recursion_limit) {
187 if (!validate_constant(state, item)) {
196 --state->recursion_depth;
209 validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx)
214 if (++state->recursion_depth > state->recursion_limit) {
268 ret = validate_exprs(state, exp->v.BoolOp.values, Load, 0);
271 ret = validate_expr(state, exp->v.BinOp.left, Load) &&
272 validate_expr(state, exp->v.BinOp.right, Load);
275 ret = validate_expr(state, exp->v.UnaryOp.operand, Load);
278 ret = validate_arguments(state, exp->v.Lambda.args) &&
279 validate_expr(state, exp->v.Lambda.body, Load);
282 ret = validate_expr(state, exp->v.IfExp.test, Load) &&
283 validate_expr(state, exp->v.IfExp.body, Load) &&
284 validate_expr(state, exp->v.IfExp.orelse, Load);
294 ret = validate_exprs(state, exp->v.Dict.keys, Load, /*null_ok=*/ 1) &&
295 validate_exprs(state, exp->v.Dict.values, Load, /*null_ok=*/ 0);
298 ret = validate_exprs(state, exp->v.Set.elts, Load, 0);
302 ret = validate_comprehension(state, exp->v.NAME.generators) && \
303 validate_expr(state, exp->v.NAME.elt, Load); \
310 ret = validate_comprehension(state, exp->v.DictComp.generators) &&
311 validate_expr(state, exp->v.DictComp.key, Load) &&
312 validate_expr(state, exp->v.DictComp.value, Load);
315 ret = !exp->v.Yield.value || validate_expr(state, exp->v.Yield.value, Load);
318 ret = validate_expr(state, exp->v.YieldFrom.value, Load);
321 ret = validate_expr(state, exp->v.Await.value, Load);
334 ret = validate_exprs(state, exp->v.Compare.comparators, Load, 0) &&
335 validate_expr(state, exp->v.Compare.left, Load);
338 ret = validate_expr(state, exp->v.Call.func, Load) &&
339 validate_exprs(state, exp->v.Call.args, Load, 0) &&
340 validate_keywords(state, exp->v.Call.keywords);
343 if (!validate_constant(state, exp->v.Constant.value)) {
349 ret = validate_exprs(state, exp->v.JoinedStr.values, Load, 0);
352 if (validate_expr(state, exp->v.FormattedValue.value, Load) == 0)
355 ret = validate_expr(state, exp->v.FormattedValue.format_spec, Load);
361 ret = validate_expr(state, exp->v.Attribute.value, Load);
364 ret = validate_expr(state, exp->v.Subscript.slice, Load) &&
365 validate_expr(state, exp->v.Subscript.value, Load);
368 ret = validate_expr(state, exp->v.Starred.value, ctx);
371 ret = (!exp->v.Slice.lower || validate_expr(state, exp->v.Slice.lower, Load)) &&
372 (!exp->v.Slice.upper || validate_expr(state, exp->v.Slice.upper, Load)) &&
373 (!exp->v.Slice.step || validate_expr(state, exp->v.Slice.step, Load));
376 ret = validate_exprs(state, exp->v.List.elts, ctx, 0);
379 ret = validate_exprs(state, exp->v.Tuple.elts, ctx, 0);
382 ret = validate_expr(state, exp->v.NamedExpr.value, Load);
394 state->recursion_depth--;
401 // validate_expr, so they don't accept the validator state
470 validate_pattern_match_value(struct validator *state, expr_ty exp)
473 if (!validate_expr(state, exp, Load)) {
483 if (!validate_expr(state, exp, Load)) {
535 validate_pattern(struct validator *state, pattern_ty p, int star_ok)
540 if (++state->recursion_depth > state->recursion_limit) {
547 ret = validate_pattern_match_value(state, p->v.MatchValue.value);
557 ret = validate_patterns(state, p->v.MatchSequence.patterns, /*star_ok=*/1);
585 if (!validate_pattern_match_value(state, key)) {
593 ret = validate_patterns(state, p->v.MatchMapping.patterns, /*star_ok=*/0);
602 if (!validate_expr(state, p->v.MatchClass.cls, Load)) {
638 if (!validate_patterns(state, p->v.MatchClass.patterns, /*star_ok=*/0)) {
643 ret = validate_patterns(state, p->v.MatchClass.kwd_patterns, /*star_ok=*/0);
667 ret = validate_pattern(state, p->v.MatchAs.pattern, /*star_ok=*/0);
677 ret = validate_patterns(state, p->v.MatchOr.patterns, /*star_ok=*/0);
686 state->recursion_depth--;
701 validate_assignlist(struct validator *state, asdl_expr_seq *targets, expr_context_ty ctx)
705 validate_exprs(state, targets, ctx, 0);
709 validate_body(struct validator *state, asdl_stmt_seq *body, const char *owner)
712 return validate_nonempty_seq(body, "body", owner) && validate_stmts(state, body);
716 validate_stmt(struct validator *state, stmt_ty stmt)
721 if (++state->recursion_depth > state->recursion_limit) {
728 ret = validate_body(state, stmt->v.FunctionDef.body, "FunctionDef") &&
729 validate_arguments(state, stmt->v.FunctionDef.args) &&
730 validate_exprs(state, stmt->v.FunctionDef.decorator_list, Load, 0) &&
732 validate_expr(state, stmt->v.FunctionDef.returns, Load));
735 ret = validate_body(state, stmt->v.ClassDef.body, "ClassDef") &&
736 validate_exprs(state, stmt->v.ClassDef.bases, Load, 0) &&
737 validate_keywords(state, stmt->v.ClassDef.keywords) &&
738 validate_exprs(state, stmt->v.ClassDef.decorator_list, Load, 0);
741 ret = !stmt->v.Return.value || validate_expr(state, stmt->v.Return.value, Load);
744 ret = validate_assignlist(state, stmt->v.Delete.targets, Del);
747 ret = validate_assignlist(state, stmt->v.Assign.targets, Store) &&
748 validate_expr(state, stmt->v.Assign.value, Load);
751 ret = validate_expr(state, stmt->v.AugAssign.target, Store) &&
752 validate_expr(state, stmt->v.AugAssign.value, Load);
761 ret = validate_expr(state, stmt->v.AnnAssign.target, Store) &&
763 validate_expr(state, stmt->v.AnnAssign.value, Load)) &&
764 validate_expr(state, stmt->v.AnnAssign.annotation, Load);
767 ret = validate_expr(state, stmt->v.For.target, Store) &&
768 validate_expr(state, stmt->v.For.iter, Load) &&
769 validate_body(state, stmt->v.For.body, "For") &&
770 validate_stmts(state, stmt->v.For.orelse);
773 ret = validate_expr(state, stmt->v.AsyncFor.target, Store) &&
774 validate_expr(state, stmt->v.AsyncFor.iter, Load) &&
775 validate_body(state, stmt->v.AsyncFor.body, "AsyncFor") &&
776 validate_stmts(state, stmt->v.AsyncFor.orelse);
779 ret = validate_expr(state, stmt->v.While.test, Load) &&
780 validate_body(state, stmt->v.While.body, "While") &&
781 validate_stmts(state, stmt->v.While.orelse);
784 ret = validate_expr(state, stmt->v.If.test, Load) &&
785 validate_body(state, stmt->v.If.body, "If") &&
786 validate_stmts(state, stmt->v.If.orelse);
793 if (!validate_expr(state, item->context_expr, Load) ||
794 (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
797 ret = validate_body(state, stmt->v.With.body, "With");
804 if (!validate_expr(state, item->context_expr, Load) ||
805 (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
808 ret = validate_body(state, stmt->v.AsyncWith.body, "AsyncWith");
811 if (!validate_expr(state, stmt->v.Match.subject, Load)
817 if (!validate_pattern(state, m->pattern, /*star_ok=*/0)
818 || (m->guard && !validate_expr(state, m->guard, Load))
819 || !validate_body(state, m->body, "match_case")) {
827 ret = validate_expr(state, stmt->v.Raise.exc, Load) &&
828 (!stmt->v.Raise.cause || validate_expr(state, stmt->v.Raise.cause, Load));
838 if (!validate_body(state, stmt->v.Try.body, "Try"))
854 !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
855 !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
859 validate_stmts(state, stmt->v.Try.finalbody)) &&
861 validate_stmts(state, stmt->v.Try.orelse));
864 if (!validate_body(state, stmt->v.TryStar.body, "TryStar"))
879 !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
880 !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
884 validate_stmts(state, stmt->v.TryStar.finalbody)) &&
886 validate_stmts(state, stmt->v.TryStar.orelse));
889 ret = validate_expr(state, stmt->v.Assert.test, Load) &&
890 (!stmt->v.Assert.msg || validate_expr(state, stmt->v.Assert.msg, Load));
909 ret = validate_expr(state, stmt->v.Expr.value, Load);
912 ret = validate_body(state, stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&
913 validate_arguments(state, stmt->v.AsyncFunctionDef.args) &&
914 validate_exprs(state, stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&
916 validate_expr(state, stmt->v.AsyncFunctionDef.returns, Load));
929 state->recursion_depth--;
934 validate_stmts(struct validator *state, asdl_stmt_seq *seq)
940 if (!validate_stmt(state, stmt))
953 validate_exprs(struct validator *state, asdl_expr_seq *exprs, expr_context_ty ctx, int null_ok)
959 if (!validate_expr(state, expr, ctx))
973 validate_patterns(struct validator *state, asdl_pattern_seq *patterns, int star_ok)
978 if (!validate_pattern(state, pattern, star_ok)) {
994 struct validator state;
1008 state.recursion_depth = starting_recursion_depth;
1009 state.recursion_limit = (recursion_limit < INT_MAX / COMPILER_STACK_FRAME_SCALE) ?
1014 res = validate_stmts(&state, mod->v.Module.body);
1017 res = validate_stmts(&state, mod->v.Interactive.body);
1020 res = validate_expr(&state, mod->v.Expression.body, Load);
1023 res = validate_exprs(&state, mod->v.FunctionType.argtypes, Load, /*null_ok=*/0) &&
1024 validate_expr(&state, mod->v.FunctionType.returns, Load);
1035 if (res && state.recursion_depth != starting_recursion_depth) {
1038 starting_recursion_depth, state.recursion_depth);