ast.c - OpenGrok cross reference for /third

Lines Matching refs:exp
209 validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx)
212     VALIDATE_POSITIONS(exp);
223     switch (exp->kind) {
225         actual_ctx = exp->v.Attribute.ctx;
228         actual_ctx = exp->v.Subscript.ctx;
231         actual_ctx = exp->v.Starred.ctx;
234         if (!validate_name(exp->v.Name.id)) {
237         actual_ctx = exp->v.Name.ctx;
240         actual_ctx = exp->v.List.ctx;
243         actual_ctx = exp->v.Tuple.ctx;
262     switch (exp->kind) {
264         if (asdl_seq_LEN(exp->v.BoolOp.values) < 2) {
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);
287         if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) {
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);
324         if (!asdl_seq_LEN(exp->v.Compare.comparators)) {
328         if (asdl_seq_LEN(exp->v.Compare.comparators) !=
329             asdl_seq_LEN(exp->v.Compare.ops)) {
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)
354         if (exp->v.FormattedValue.format_spec) {
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);
403 ensure_literal_number(expr_ty exp, bool allow_real, bool allow_imaginary)
405     assert(exp->kind == Constant_kind);
406     PyObject *value = exp->v.Constant.value;
413 ensure_literal_negative(expr_ty exp, bool allow_real, bool allow_imaginary)
415     assert(exp->kind == UnaryOp_kind);
417     if (exp->v.UnaryOp.op != USub) {
421     expr_ty operand = exp->v.UnaryOp.operand;
430 ensure_literal_complex(expr_ty exp)
432     assert(exp->kind == BinOp_kind);
433     expr_ty left = exp->v.BinOp.left;
434     expr_ty right = exp->v.BinOp.right;
436     if (exp->v.BinOp.op != Add && exp->v.BinOp.op != Sub) {
470 validate_pattern_match_value(struct validator *state, expr_ty exp)
473     if (!validate_expr(state, exp, Load)) {
477     switch (exp->kind)
483             if (!validate_expr(state, exp, Load)) {
486             PyObject *literal = exp->v.Constant.value;
501             if (ensure_literal_negative(exp, /*real=*/true, /*imaginary=*/true)) {
508             if (ensure_literal_complex(exp)) {