From 992d4a3e6e67a05b85350820157028a61d1f22cf Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Wed, 11 Jul 2007 13:09:30 +0000 Subject: Merged revisions 56154-56264 via svnmerge from svn+ssh://pythondev@svn.python.org/python/branches/p3yk ................ r56155 | neal.norwitz | 2007-07-03 08:59:08 +0300 (Tue, 03 Jul 2007) | 1 line Get this test working after converting map to return an iterator ................ r56202 | neal.norwitz | 2007-07-09 04:30:09 +0300 (Mon, 09 Jul 2007) | 37 lines Merged revisions 56124-56201 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r56129 | georg.brandl | 2007-06-30 04:01:01 -0700 (Sat, 30 Jun 2007) | 2 lines Document smtp.SMTPAuthenticationError. ........ r56137 | georg.brandl | 2007-07-01 01:11:35 -0700 (Sun, 01 Jul 2007) | 2 lines Fix a few webbrowser.py problems. ........ r56143 | georg.brandl | 2007-07-02 04:54:28 -0700 (Mon, 02 Jul 2007) | 2 lines Remove duplicate sentence from alarm() doc. ........ r56170 | mark.hammond | 2007-07-03 19:03:10 -0700 (Tue, 03 Jul 2007) | 3 lines copy built files to the PCBuild directory, where tools like distutils or external build processes can find them. ........ r56176 | kurt.kaiser | 2007-07-05 15:03:39 -0700 (Thu, 05 Jul 2007) | 10 lines Many calls to tk.call involve an arglist containing a single tuple. Calls using METH_OLDARGS unpack this tuple; calls using METH_VARARG don't. Tcl's concatenation of args was affected; IDLE doesn't start. Modify Tkapp_Call() to unpack single tuple arglists. Bug 1733943 Ref http://mail.python.org/pipermail/python-checkins/2007-May/060454.html ........ r56177 | neal.norwitz | 2007-07-05 21:13:39 -0700 (Thu, 05 Jul 2007) | 1 line Fix typo in comment ........ ................ r56251 | neal.norwitz | 2007-07-11 10:01:01 +0300 (Wed, 11 Jul 2007) | 1 line Get working with map returning an iterator (had to fix whitespace too) ................ r56255 | thomas.wouters | 2007-07-11 13:41:37 +0300 (Wed, 11 Jul 2007) | 6 lines Clean up merge glitch or copy-paste error (the entire module was duplicated, except the first half even had some more copy-paste errors, referring to listcomps and genexps instead of setcomps) ................ r56256 | thomas.wouters | 2007-07-11 15:16:01 +0300 (Wed, 11 Jul 2007) | 14 lines Dict comprehensions. Still needs doc changes (like many python-3000 features ;-). It generates bytecode similar to: x = {} for k, v in (generator here): x[k] = v except there is no tuple-packing and -unpacking involved. Trivial measurement suggests it's significantly faster than dict(generator here) (in the order of 2 to 3 times as fast) but I have not done extensive measurements. ................ r56263 | guido.van.rossum | 2007-07-11 15:36:26 +0300 (Wed, 11 Jul 2007) | 3 lines Patch 1724999 by Ali Gholami Rudi -- avoid complaints about dict size change during iter in destroy call. ................ --- Python/compile.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 55 insertions(+), 9 deletions(-) (limited to 'Python/compile.c') diff --git a/Python/compile.c b/Python/compile.c index cbb6b4d61a..77c6a775b7 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -42,6 +42,7 @@ int Py_OptimizeFlag = 0; #define COMP_GENEXP 0 #define COMP_LISTCOMP 1 #define COMP_SETCOMP 2 +#define COMP_DICTCOMP 3 struct instr { unsigned i_jabs : 1; @@ -2753,7 +2754,7 @@ compiler_call_helper(struct compiler *c, static int compiler_comprehension_generator(struct compiler *c, PyObject *tmpname, asdl_seq *generators, int gen_index, - expr_ty elt, int type) + expr_ty elt, expr_ty val, int type) { /* generate code for the iterator, then each of the ifs, and then write to the element */ @@ -2801,7 +2802,7 @@ compiler_comprehension_generator(struct compiler *c, PyObject *tmpname, if (++gen_index < asdl_seq_LEN(generators)) if (!compiler_comprehension_generator(c, tmpname, generators, gen_index, - elt, type)) + elt, val, type)) return 0; /* only append after the last for generator */ @@ -2825,6 +2826,17 @@ compiler_comprehension_generator(struct compiler *c, PyObject *tmpname, VISIT(c, expr, elt); ADDOP(c, SET_ADD); break; + case COMP_DICTCOMP: + if (!compiler_nameop(c, tmpname, Load)) + return 0; + /* With 'd[k] = v', v is evaluated before k, so we do + the same. STORE_SUBSCR requires (item, map, key), + so we still end up ROTing once. */ + VISIT(c, expr, val); + ADDOP(c, ROT_TWO); + VISIT(c, expr, elt); + ADDOP(c, STORE_SUBSCR); + break; default: return 0; } @@ -2846,7 +2858,7 @@ compiler_comprehension_generator(struct compiler *c, PyObject *tmpname, static int compiler_comprehension(struct compiler *c, expr_ty e, int type, identifier name, - asdl_seq *generators, expr_ty elt) + asdl_seq *generators, expr_ty elt, expr_ty val) { PyCodeObject *co = NULL; identifier tmp = NULL; @@ -2859,18 +2871,34 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type, identifier name, goto error; if (type != COMP_GENEXP) { + int op; tmp = compiler_new_tmpname(c); if (!tmp) goto error_in_scope; + switch (type) { + case COMP_LISTCOMP: + op = BUILD_LIST; + break; + case COMP_SETCOMP: + op = BUILD_SET; + break; + case COMP_DICTCOMP: + op = BUILD_MAP; + break; + default: + PyErr_Format(PyExc_SystemError, + "unknown comprehension type %d", type); + goto error_in_scope; + } - ADDOP_I(c, (type == COMP_LISTCOMP ? - BUILD_LIST : BUILD_SET), 0); + ADDOP_I(c, op, 0); ADDOP(c, DUP_TOP); if (!compiler_nameop(c, tmp, Store)) goto error_in_scope; } - if (!compiler_comprehension_generator(c, tmp, generators, 0, elt, type)) + if (!compiler_comprehension_generator(c, tmp, generators, 0, elt, + val, type)) goto error_in_scope; if (type != COMP_GENEXP) { @@ -2911,7 +2939,7 @@ compiler_genexp(struct compiler *c, expr_ty e) assert(e->kind == GeneratorExp_kind); return compiler_comprehension(c, e, COMP_GENEXP, name, e->v.GeneratorExp.generators, - e->v.GeneratorExp.elt); + e->v.GeneratorExp.elt, NULL); } static int @@ -2926,7 +2954,7 @@ compiler_listcomp(struct compiler *c, expr_ty e) assert(e->kind == ListComp_kind); return compiler_comprehension(c, e, COMP_LISTCOMP, name, e->v.ListComp.generators, - e->v.ListComp.elt); + e->v.ListComp.elt, NULL); } static int @@ -2941,7 +2969,23 @@ compiler_setcomp(struct compiler *c, expr_ty e) assert(e->kind == SetComp_kind); return compiler_comprehension(c, e, COMP_SETCOMP, name, e->v.SetComp.generators, - e->v.SetComp.elt); + e->v.SetComp.elt, NULL); +} + + +static int +compiler_dictcomp(struct compiler *c, expr_ty e) +{ + static identifier name; + if (!name) { + name = PyString_FromString(""); + if (!name) + return 0; + } + assert(e->kind == DictComp_kind); + return compiler_comprehension(c, e, COMP_DICTCOMP, name, + e->v.DictComp.generators, + e->v.DictComp.key, e->v.DictComp.value); } @@ -3173,6 +3217,8 @@ compiler_visit_expr(struct compiler *c, expr_ty e) return compiler_listcomp(c, e); case SetComp_kind: return compiler_setcomp(c, e); + case DictComp_kind: + return compiler_dictcomp(c, e); case Yield_kind: if (c->u->u_ste->ste_type != FunctionBlock) return compiler_error(c, "'yield' outside function"); -- cgit v1.2.1