From 7b782b61c597a989a21a22c15ee95decf997429f Mon Sep 17 00:00:00 2001 From: Anthony Baxter Date: Tue, 11 Apr 2006 12:01:56 +0000 Subject: [PATCH] more low-hanging fruit to make code compile under a C++ compiler. Not entirely happy with the two new VISIT macros in compile.c, but I couldn't see a better approach. --- Parser/pgenmain.c | 4 +- Python/compile.c | 139 ++++++++++++++++++++++++++++------------------ Python/future.c | 4 +- Python/pyarena.c | 8 +-- Python/pystate.c | 17 +++--- 5 files changed, 102 insertions(+), 70 deletions(-) diff --git a/Parser/pgenmain.c b/Parser/pgenmain.c index 6e22e378193..fc27a2cd125 100644 --- a/Parser/pgenmain.c +++ b/Parser/pgenmain.c @@ -136,7 +136,7 @@ char * PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt) { size_t n = 1000; - char *p = PyMem_MALLOC(n); + char *p = (char *)PyMem_MALLOC(n); char *q; if (p == NULL) return NULL; @@ -149,7 +149,7 @@ PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt) n = strlen(p); if (n > 0 && p[n-1] != '\n') p[n-1] = '\n'; - return PyMem_REALLOC(p, n+1); + return (char *)PyMem_REALLOC(p, n+1); } /* No-nonsense fgets */ diff --git a/Python/compile.c b/Python/compile.c index 6c8ec53d6ac..69671dc360a 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -197,19 +197,19 @@ static PyCodeObject *assemble(struct compiler *, int addNone); static PyObject *__doc__; PyObject * -_Py_Mangle(PyObject *private, PyObject *ident) +_Py_Mangle(PyObject *privateobj, PyObject *ident) { /* Name mangling: __private becomes _classname__private. This is independent from how the name is used. */ const char *p, *name = PyString_AsString(ident); char *buffer; size_t nlen, plen; - if (private == NULL || name == NULL || name[0] != '_' || + if (privateobj == NULL || name == NULL || name[0] != '_' || name[1] != '_') { Py_INCREF(ident); return ident; } - p = PyString_AsString(private); + p = PyString_AsString(privateobj); nlen = strlen(name); if (name[nlen-1] == '_' && name[nlen-2] == '_') { Py_INCREF(ident); @@ -612,7 +612,7 @@ fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts) static unsigned int * markblocks(unsigned char *code, int len) { - unsigned int *blocks = PyMem_Malloc(len*sizeof(int)); + unsigned int *blocks = (unsigned int *)PyMem_Malloc(len*sizeof(int)); int i,j, opcode, blockcnt = 0; if (blocks == NULL) @@ -693,10 +693,11 @@ optimize_code(PyObject *code, PyObject* consts, PyObject *names, goto exitUnchanged; /* Make a modifiable copy of the code string */ - codestr = PyMem_Malloc(codelen); + codestr = (unsigned char *)PyMem_Malloc(codelen); if (codestr == NULL) goto exitUnchanged; - codestr = memcpy(codestr, PyString_AS_STRING(code), codelen); + codestr = (unsigned char *)memcpy(codestr, + PyString_AS_STRING(code), codelen); /* Verify that RETURN_VALUE terminates the codestring. This allows the various transformation patterns to look ahead several @@ -707,7 +708,7 @@ optimize_code(PyObject *code, PyObject* consts, PyObject *names, goto exitUnchanged; /* Mapping to new jump targets after NOPs are removed */ - addrmap = PyMem_Malloc(codelen * sizeof(int)); + addrmap = (int *)PyMem_Malloc(codelen * sizeof(int)); if (addrmap == NULL) goto exitUnchanged; @@ -1087,7 +1088,8 @@ compiler_enter_scope(struct compiler *c, identifier name, void *key, { struct compiler_unit *u; - u = PyObject_Malloc(sizeof(struct compiler_unit)); + u = (struct compiler_unit *)PyObject_Malloc(sizeof( + struct compiler_unit)); if (!u) { PyErr_NoMemory(); return 0; @@ -1243,8 +1245,8 @@ compiler_next_instr(struct compiler *c, basicblock *b) { assert(b != NULL); if (b->b_instr == NULL) { - b->b_instr = PyObject_Malloc(sizeof(struct instr) * - DEFAULT_BLOCK_SIZE); + b->b_instr = (struct instr *)PyObject_Malloc( + sizeof(struct instr) * DEFAULT_BLOCK_SIZE); if (b->b_instr == NULL) { PyErr_NoMemory(); return -1; @@ -1262,7 +1264,8 @@ compiler_next_instr(struct compiler *c, basicblock *b) return -1; } b->b_ialloc <<= 1; - b->b_instr = PyObject_Realloc((void *)b->b_instr, newsize); + b->b_instr = (struct instr *)PyObject_Realloc( + (void *)b->b_instr, newsize); if (b->b_instr == NULL) return -1; memset((char *)b->b_instr + oldsize, 0, newsize - oldsize); @@ -1720,6 +1723,16 @@ compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute) } \ } +#define VISIT_SEQ_WITH_CAST(C, TYPE, SEQ, CAST) { \ + int _i; \ + asdl_seq *seq = (SEQ); /* avoid variable capture */ \ + for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ + TYPE ## _ty elt = (CAST)asdl_seq_GET(seq, _i); \ + if (!compiler_visit_ ## TYPE((C), elt)) \ + return 0; \ + } \ +} + #define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \ int _i; \ asdl_seq *seq = (SEQ); /* avoid variable capture */ \ @@ -1732,6 +1745,18 @@ compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute) } \ } +#define VISIT_SEQ_IN_SCOPE_WITH_CAST(C, TYPE, SEQ, CAST) { \ + int _i; \ + asdl_seq *seq = (SEQ); /* avoid variable capture */ \ + for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \ + TYPE ## _ty elt = (CAST)asdl_seq_GET(seq, _i); \ + if (!compiler_visit_ ## TYPE((C), elt)) { \ + compiler_exit_scope(c); \ + return 0; \ + } \ + } \ +} + static int compiler_isdocstring(stmt_ty s) { @@ -1750,7 +1775,7 @@ compiler_body(struct compiler *c, asdl_seq *stmts) if (!asdl_seq_LEN(stmts)) return 1; - st = asdl_seq_GET(stmts, 0); + st = (stmt_ty)asdl_seq_GET(stmts, 0); if (compiler_isdocstring(st)) { i = 1; VISIT(c, expr, st->v.Expr.value); @@ -1758,7 +1783,7 @@ compiler_body(struct compiler *c, asdl_seq *stmts) return 0; } for (; i < asdl_seq_LEN(stmts); i++) - VISIT(c, stmt, asdl_seq_GET(stmts, i)); + VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i)); return 1; } @@ -1784,7 +1809,8 @@ compiler_mod(struct compiler *c, mod_ty mod) break; case Interactive_kind: c->c_interactive = 1; - VISIT_SEQ_IN_SCOPE(c, stmt, mod->v.Interactive.body); + VISIT_SEQ_IN_SCOPE_WITH_CAST(c, stmt, + mod->v.Interactive.body, stmt_ty); break; case Expression_kind: VISIT_IN_SCOPE(c, expr, mod->v.Expression.body); @@ -1901,7 +1927,7 @@ compiler_decorators(struct compiler *c, asdl_seq* decos) return 1; for (i = 0; i < asdl_seq_LEN(decos); i++) { - VISIT(c, expr, asdl_seq_GET(decos, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i)); } return 1; } @@ -1913,7 +1939,7 @@ compiler_arguments(struct compiler *c, arguments_ty args) int n = asdl_seq_LEN(args->args); /* Correctly handle nested argument lists */ for (i = 0; i < n; i++) { - expr_ty arg = asdl_seq_GET(args->args, i); + expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i); if (arg->kind == Tuple_kind) { PyObject *id = PyString_FromFormat(".%d", i); if (id == NULL) { @@ -1945,12 +1971,12 @@ compiler_function(struct compiler *c, stmt_ty s) if (!compiler_decorators(c, decos)) return 0; if (args->defaults) - VISIT_SEQ(c, expr, args->defaults); + VISIT_SEQ_WITH_CAST(c, expr, args->defaults, expr_ty); if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s, s->lineno)) return 0; - st = asdl_seq_GET(s->v.FunctionDef.body, 0); + st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0); docstring = compiler_isdocstring(st); if (docstring) first_const = st->v.Expr.value->v.Str.s; @@ -1966,7 +1992,7 @@ compiler_function(struct compiler *c, stmt_ty s) n = asdl_seq_LEN(s->v.FunctionDef.body); /* if there was a docstring, we need to skip the first statement */ for (i = docstring; i < n; i++) { - stmt_ty s2 = asdl_seq_GET(s->v.FunctionDef.body, i); + stmt_ty s2 = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i); if (i == 0 && s2->kind == Expr_kind && s2->v.Expr.value->kind == Str_kind) continue; @@ -1998,7 +2024,7 @@ compiler_class(struct compiler *c, stmt_ty s) /* push the tuple of base classes on the stack */ n = asdl_seq_LEN(s->v.ClassDef.bases); if (n > 0) - VISIT_SEQ(c, expr, s->v.ClassDef.bases); + VISIT_SEQ_WITH_CAST(c, expr, s->v.ClassDef.bases, expr_ty); ADDOP_I(c, BUILD_TUPLE, n); if (!compiler_enter_scope(c, s->v.ClassDef.name, (void *)s, s->lineno)) @@ -2082,7 +2108,7 @@ compiler_lambda(struct compiler *c, expr_ty e) } if (args->defaults) - VISIT_SEQ(c, expr, args->defaults); + VISIT_SEQ_WITH_CAST(c, expr, args->defaults, expr_ty); if (!compiler_enter_scope(c, name, (void *)e, e->lineno)) return 0; @@ -2155,12 +2181,12 @@ compiler_if(struct compiler *c, stmt_ty s) VISIT(c, expr, s->v.If.test); ADDOP_JREL(c, JUMP_IF_FALSE, next); ADDOP(c, POP_TOP); - VISIT_SEQ(c, stmt, s->v.If.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.If.body, stmt_ty); ADDOP_JREL(c, JUMP_FORWARD, end); compiler_use_next_block(c, next); ADDOP(c, POP_TOP); if (s->v.If.orelse) - VISIT_SEQ(c, stmt, s->v.If.orelse); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.If.orelse, stmt_ty); compiler_use_next_block(c, end); return 1; } @@ -2183,12 +2209,12 @@ compiler_for(struct compiler *c, stmt_ty s) compiler_use_next_block(c, start); ADDOP_JREL(c, FOR_ITER, cleanup); VISIT(c, expr, s->v.For.target); - VISIT_SEQ(c, stmt, s->v.For.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.For.body, stmt_ty); ADDOP_JABS(c, JUMP_ABSOLUTE, start); compiler_use_next_block(c, cleanup); ADDOP(c, POP_BLOCK); compiler_pop_fblock(c, LOOP, start); - VISIT_SEQ(c, stmt, s->v.For.orelse); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.For.orelse, stmt_ty); compiler_use_next_block(c, end); return 1; } @@ -2227,7 +2253,7 @@ compiler_while(struct compiler *c, stmt_ty s) ADDOP_JREL(c, JUMP_IF_FALSE, anchor); ADDOP(c, POP_TOP); } - VISIT_SEQ(c, stmt, s->v.While.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.While.body, stmt_ty); ADDOP_JABS(c, JUMP_ABSOLUTE, loop); /* XXX should the two POP instructions be in a separate block @@ -2241,7 +2267,7 @@ compiler_while(struct compiler *c, stmt_ty s) } compiler_pop_fblock(c, LOOP, loop); if (orelse != NULL) /* what if orelse is just pass? */ - VISIT_SEQ(c, stmt, s->v.While.orelse); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.While.orelse, stmt_ty); compiler_use_next_block(c, end); return 1; @@ -2322,7 +2348,7 @@ compiler_try_finally(struct compiler *c, stmt_ty s) compiler_use_next_block(c, body); if (!compiler_push_fblock(c, FINALLY_TRY, body)) return 0; - VISIT_SEQ(c, stmt, s->v.TryFinally.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.TryFinally.body, stmt_ty); ADDOP(c, POP_BLOCK); compiler_pop_fblock(c, FINALLY_TRY, body); @@ -2330,7 +2356,7 @@ compiler_try_finally(struct compiler *c, stmt_ty s) compiler_use_next_block(c, end); if (!compiler_push_fblock(c, FINALLY_END, end)) return 0; - VISIT_SEQ(c, stmt, s->v.TryFinally.finalbody); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.TryFinally.finalbody, stmt_ty); ADDOP(c, END_FINALLY); compiler_pop_fblock(c, FINALLY_END, end); @@ -2387,14 +2413,14 @@ compiler_try_except(struct compiler *c, stmt_ty s) compiler_use_next_block(c, body); if (!compiler_push_fblock(c, EXCEPT, body)) return 0; - VISIT_SEQ(c, stmt, s->v.TryExcept.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.TryExcept.body, stmt_ty); ADDOP(c, POP_BLOCK); compiler_pop_fblock(c, EXCEPT, body); ADDOP_JREL(c, JUMP_FORWARD, orelse); n = asdl_seq_LEN(s->v.TryExcept.handlers); compiler_use_next_block(c, except); for (i = 0; i < n; i++) { - excepthandler_ty handler = asdl_seq_GET( + excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET( s->v.TryExcept.handlers, i); if (!handler->type && i < n-1) return compiler_error(c, "default 'except:' must be last"); @@ -2418,7 +2444,7 @@ compiler_try_except(struct compiler *c, stmt_ty s) ADDOP(c, POP_TOP); } ADDOP(c, POP_TOP); - VISIT_SEQ(c, stmt, handler->body); + VISIT_SEQ_WITH_CAST(c, stmt, handler->body, stmt_ty); ADDOP_JREL(c, JUMP_FORWARD, end); compiler_use_next_block(c, except); if (handler->type) @@ -2426,7 +2452,7 @@ compiler_try_except(struct compiler *c, stmt_ty s) } ADDOP(c, END_FINALLY); compiler_use_next_block(c, orelse); - VISIT_SEQ(c, stmt, s->v.TryExcept.orelse); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.TryExcept.orelse, stmt_ty); compiler_use_next_block(c, end); return 1; } @@ -2474,7 +2500,7 @@ compiler_import(struct compiler *c, stmt_ty s) int i, n = asdl_seq_LEN(s->v.Import.names); for (i = 0; i < n; i++) { - alias_ty alias = asdl_seq_GET(s->v.Import.names, i); + alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i); int r; PyObject *level; @@ -2538,7 +2564,7 @@ compiler_from_import(struct compiler *c, stmt_ty s) /* build up the names */ for (i = 0; i < n; i++) { - alias_ty alias = asdl_seq_GET(s->v.ImportFrom.names, i); + alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); Py_INCREF(alias->name); PyTuple_SET_ITEM(names, i, alias->name); } @@ -2561,7 +2587,7 @@ compiler_from_import(struct compiler *c, stmt_ty s) Py_DECREF(names); ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names); for (i = 0; i < n; i++) { - alias_ty alias = asdl_seq_GET(s->v.ImportFrom.names, i); + alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i); identifier store_name; if (i == 0 && *PyString_AS_STRING(alias->name) == '*') { @@ -2646,7 +2672,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) ADDOP(c, RETURN_VALUE); break; case Delete_kind: - VISIT_SEQ(c, expr, s->v.Delete.targets) + VISIT_SEQ_WITH_CAST(c, expr, s->v.Delete.targets, expr_ty) break; case Assign_kind: n = asdl_seq_LEN(s->v.Assign.targets); @@ -3000,11 +3026,11 @@ compiler_boolop(struct compiler *c, expr_ty e) s = e->v.BoolOp.values; n = asdl_seq_LEN(s) - 1; for (i = 0; i < n; ++i) { - VISIT(c, expr, asdl_seq_GET(s, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i)); ADDOP_JREL(c, jumpi, end); ADDOP(c, POP_TOP) } - VISIT(c, expr, asdl_seq_GET(s, n)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n)); compiler_use_next_block(c, end); return 1; } @@ -3016,7 +3042,7 @@ compiler_list(struct compiler *c, expr_ty e) if (e->v.List.ctx == Store) { ADDOP_I(c, UNPACK_SEQUENCE, n); } - VISIT_SEQ(c, expr, e->v.List.elts); + VISIT_SEQ_WITH_CAST(c, expr, e->v.List.elts, expr_ty); if (e->v.List.ctx == Load) { ADDOP_I(c, BUILD_LIST, n); } @@ -3030,7 +3056,7 @@ compiler_tuple(struct compiler *c, expr_ty e) if (e->v.Tuple.ctx == Store) { ADDOP_I(c, UNPACK_SEQUENCE, n); } - VISIT_SEQ(c, expr, e->v.Tuple.elts); + VISIT_SEQ_WITH_CAST(c, expr, e->v.Tuple.elts, expr_ty); if (e->v.Tuple.ctx == Load) { ADDOP_I(c, BUILD_TUPLE, n); } @@ -3051,7 +3077,8 @@ compiler_compare(struct compiler *c, expr_ty e) cleanup = compiler_new_block(c); if (cleanup == NULL) return 0; - VISIT(c, expr, asdl_seq_GET(e->v.Compare.comparators, 0)); + VISIT(c, expr, + (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0)); } for (i = 1; i < n; i++) { ADDOP(c, DUP_TOP); @@ -3063,9 +3090,10 @@ compiler_compare(struct compiler *c, expr_ty e) NEXT_BLOCK(c); ADDOP(c, POP_TOP); if (i < (n - 1)) - VISIT(c, expr, asdl_seq_GET(e->v.Compare.comparators, i)); + VISIT(c, expr, + (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i)); } - VISIT(c, expr, asdl_seq_GET(e->v.Compare.comparators, n - 1)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n - 1)); ADDOP_I(c, COMPARE_OP, /* XXX We're casting a void* to cmpop_ty in the next stmt. */ cmpop((cmpop_ty)asdl_seq_GET(e->v.Compare.ops, n - 1))); @@ -3089,9 +3117,9 @@ compiler_call(struct compiler *c, expr_ty e) VISIT(c, expr, e->v.Call.func); n = asdl_seq_LEN(e->v.Call.args); - VISIT_SEQ(c, expr, e->v.Call.args); + VISIT_SEQ_WITH_CAST(c, expr, e->v.Call.args, expr_ty); if (e->v.Call.keywords) { - VISIT_SEQ(c, keyword, e->v.Call.keywords); + VISIT_SEQ_WITH_CAST(c, keyword, e->v.Call.keywords, keyword_ty); n |= asdl_seq_LEN(e->v.Call.keywords) << 8; } if (e->v.Call.starargs) { @@ -3140,7 +3168,7 @@ compiler_listcomp_generator(struct compiler *c, PyObject *tmpname, anchor == NULL) return 0; - l = asdl_seq_GET(generators, gen_index); + l = (comprehension_ty)asdl_seq_GET(generators, gen_index); VISIT(c, expr, l->iter); ADDOP(c, GET_ITER); compiler_use_next_block(c, start); @@ -3151,7 +3179,7 @@ compiler_listcomp_generator(struct compiler *c, PyObject *tmpname, /* XXX this needs to be cleaned up...a lot! */ n = asdl_seq_LEN(l->ifs); for (i = 0; i < n; i++) { - expr_ty e = asdl_seq_GET(l->ifs, i); + expr_ty e = (expr_ty)asdl_seq_GET(l->ifs, i); VISIT(c, expr, e); ADDOP_JREL(c, JUMP_IF_FALSE, if_cleanup); NEXT_BLOCK(c); @@ -3236,7 +3264,7 @@ compiler_genexp_generator(struct compiler *c, anchor == NULL || end == NULL) return 0; - ge = asdl_seq_GET(generators, gen_index); + ge = (comprehension_ty)asdl_seq_GET(generators, gen_index); ADDOP_JREL(c, SETUP_LOOP, end); if (!compiler_push_fblock(c, LOOP, start)) return 0; @@ -3259,7 +3287,7 @@ compiler_genexp_generator(struct compiler *c, /* XXX this needs to be cleaned up...a lot! */ n = asdl_seq_LEN(ge->ifs); for (i = 0; i < n; i++) { - expr_ty e = asdl_seq_GET(ge->ifs, i); + expr_ty e = (expr_ty)asdl_seq_GET(ge->ifs, i); VISIT(c, expr, e); ADDOP_JREL(c, JUMP_IF_FALSE, if_cleanup); NEXT_BLOCK(c); @@ -3472,7 +3500,7 @@ compiler_with(struct compiler *c, stmt_ty s) } /* BLOCK code */ - VISIT_SEQ(c, stmt, s->v.With.body); + VISIT_SEQ_WITH_CAST(c, stmt, s->v.With.body, stmt_ty); /* End of try block; start the finally block */ ADDOP(c, POP_BLOCK); @@ -3531,9 +3559,11 @@ compiler_visit_expr(struct compiler *c, expr_ty e) It wants the stack to look like (value) (dict) (key) */ for (i = 0; i < n; i++) { ADDOP(c, DUP_TOP); - VISIT(c, expr, asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, + (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); ADDOP(c, ROT_TWO); - VISIT(c, expr, asdl_seq_GET(e->v.Dict.keys, i)); + VISIT(c, expr, + (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); ADDOP(c, STORE_SUBSCR); } break; @@ -3900,7 +3930,8 @@ compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx) if (ctx != AugStore) { int i, n = asdl_seq_LEN(s->v.ExtSlice.dims); for (i = 0; i < n; i++) { - slice_ty sub = asdl_seq_GET(s->v.ExtSlice.dims, i); + slice_ty sub = (slice_ty)asdl_seq_GET( + s->v.ExtSlice.dims, i); if (!compiler_visit_nested_slice(c, sub, ctx)) return 0; } diff --git a/Python/future.c b/Python/future.c index 04fec22fd8c..560077d4d06 100644 --- a/Python/future.c +++ b/Python/future.c @@ -19,7 +19,7 @@ future_check_features(PyFutureFeatures *ff, stmt_ty s, const char *filename) names = s->v.ImportFrom.names; for (i = 0; i < asdl_seq_LEN(names); i++) { - alias_ty name = asdl_seq_GET(names, i); + alias_ty name = (alias_ty)asdl_seq_GET(names, i); const char *feature = PyString_AsString(name->name); if (!feature) return 0; @@ -73,7 +73,7 @@ future_parse(PyFutureFeatures *ff, mod_ty mod, const char *filename) for (i = 0; i < asdl_seq_LEN(mod->v.Module.body); i++) { - stmt_ty s = asdl_seq_GET(mod->v.Module.body, i); + stmt_ty s = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i); if (done && s->lineno > prev_line) return 1; diff --git a/Python/pyarena.c b/Python/pyarena.c index 012c46bcea1..f27de8676dc 100644 --- a/Python/pyarena.c +++ b/Python/pyarena.c @@ -105,14 +105,14 @@ block_alloc(block *b, size_t size) the default block, allocate a one-off block that is exactly the right size. */ /* TODO(jhylton): Think about space waste at end of block */ - block *new = block_new( + block *newbl = block_new( size < DEFAULT_BLOCK_SIZE ? DEFAULT_BLOCK_SIZE : size); - if (!new) + if (!newbl) return NULL; assert(!b->ab_next); - b->ab_next = new; - b = new; + b->ab_next = newbl; + b = newbl; } assert(b->ab_offset + size <= b->ab_size); diff --git a/Python/pystate.c b/Python/pystate.c index 867334e81e0..ca19b760eb3 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -297,23 +297,23 @@ PyThreadState_Get(void) PyThreadState * -PyThreadState_Swap(PyThreadState *new) +PyThreadState_Swap(PyThreadState *newts) { - PyThreadState *old = _PyThreadState_Current; + PyThreadState *oldts = _PyThreadState_Current; - _PyThreadState_Current = new; + _PyThreadState_Current = newts; /* It should not be possible for more than one thread state to be used for a thread. Check this the best we can in debug builds. */ #if defined(Py_DEBUG) && defined(WITH_THREAD) - if (new) { + if (newts) { PyThreadState *check = PyGILState_GetThisThreadState(); - if (check && check->interp == new->interp && check != new) + if (check && check->interp == newts->interp && check != newts) Py_FatalError("Invalid thread state for this thread"); } #endif - return old; + return oldts; } /* An extension mechanism to store arbitrary additional per-thread state. @@ -491,7 +491,7 @@ PyGILState_Ensure(void) called Py_Initialize() and usually PyEval_InitThreads(). */ assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */ - tcur = PyThread_get_key_value(autoTLSkey); + tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey); if (tcur == NULL) { /* Create a new thread state for this thread */ tcur = PyThreadState_New(autoInterpreterState); @@ -518,7 +518,8 @@ PyGILState_Ensure(void) void PyGILState_Release(PyGILState_STATE oldstate) { - PyThreadState *tcur = PyThread_get_key_value(autoTLSkey); + PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value( + autoTLSkey); if (tcur == NULL) Py_FatalError("auto-releasing thread-state, " "but no thread-state for this thread");