From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 11183 invoked by alias); 4 Aug 2014 16:55:16 -0000 Mailing-List: contact zsh-workers-help@zsh.org; run by ezmlm Precedence: bulk X-No-Archive: yes List-Id: Zsh Workers List List-Post: List-Help: X-Seq: 32949 Received: (qmail 17930 invoked from network); 4 Aug 2014 16:55:05 -0000 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on f.primenet.com.au X-Spam-Level: X-Spam-Status: No, score=-2.7 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW autolearn=ham version=3.3.2 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:subject:date:message-id:in-reply-to:references; bh=xSkgNIZtPT3+yR/DSFgl06lEg0OXYONp64idoqZoP1I=; b=Ar9EAz9adpqMgEKM+7xkFMxzH90vZ6wx+czAuAQpZNcijUvLfX/IaQIIgSoU47L/KI 3wdOjlYfBdBSpOJhUDsm9GSw9jlXwc9+O9iZpz8xGUNnP3fH3k6sjqxHxgZ6SdJIXYmm xPY0YX3P0vkRlUOw4+tHR6MrldQ2IpMsKGURU46aYxNQWMzZjpDVPJjrjlKZ7no/AYfd JeiLmCFMc/qpvWe1vFx/LLnsdKFey6fP3RPf5ZQAbu5vVQtsx9KLit04UMqG8GYsxSG4 nrqExspjD1IyvdAl18l4gpF2+rzC037trwWbgcfFYeCo2U7VYzDbe/9u9ogcplvGx9rM OuXA== X-Received: by 10.112.204.36 with SMTP id kv4mr3482083lbc.106.1407171301194; Mon, 04 Aug 2014 09:55:01 -0700 (PDT) From: Mikael Magnusson To: zsh-workers@zsh.org Subject: PATCH: Add :^ syntax for zipping two arrays (v3) Date: Mon, 4 Aug 2014 18:51:28 +0200 Message-Id: <1407171088-8740-1-git-send-email-mikachu@gmail.com> X-Mailer: git-send-email 1.9.0 In-Reply-To: <20140804170737.401d8a75@pwslap01u.europe.root.pri> References: <20140804170737.401d8a75@pwslap01u.europe.root.pri> This includes tests, updated docs to mention the "${a:^a}" thing, and fixes a crash discovered by adding tests. (When either of the arrays were empty, the :^^ form attempted to divide by 0). --- Doc/Zsh/expn.yo | 24 ++++++++++++++++ Src/subst.c | 61 ++++++++++++++++++++++++++++++++++++++++ Test/D04parameter.ztst | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 161 insertions(+) diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo index 7279013..8394ffc 100644 --- a/Doc/Zsh/expn.yo +++ b/Doc/Zsh/expn.yo @@ -636,6 +636,30 @@ Similar to the preceding subsitution, but in the opposite sense, so that entries present in both the original substitution and as elements of var(arrayname) are retained and others removed. ) +xitem(tt(${)var(name)tt(:^)var(arrayname)tt(})) +item(tt(${)var(name)tt(:^^)var(arrayname)tt(}))( +Zips two arrays, such that the output array is twice as long as the +shortest (longest for `tt(:^^)') of tt(name) and tt(arrayname), with +the elements alternatingly being picked from them. For `tt(:^)', if one +of the input arrays is longer, the output will stop when the end of the +shorter array is reached. Thus, + +example(a=(1 2 3 4); b=(a b); print ${a:^b}) + +will output `tt(1 a 2 b)'. For `tt(:^^)', then the input is repeated +until all of the longer array has been used up and the above will output +`tt(1 a 2 b 3 a 4 b)'. + +Either or both inputs may be a scalar, they will be treated as an array +of length 1 with the scalar as the only element. If either array is empty, +the other array is output with no extra elements inserted. + +Currently the following code will output `tt(a b)' and `tt(1)' as two separate +elements, which can be unexpected. The second print provides a workaround which +should continue to work if this is changed. + +example(a=(a b); b=(1 2); print -l "${a:^b}"; print -l "${${a:^b}}") +) xitem(tt(${)var(name)tt(:)var(offset)tt(})) item(tt(${)var(name)tt(:)var(offset)tt(:)var(length)tt(}))( This syntax gives effects similar to parameter subscripting diff --git a/Src/subst.c b/Src/subst.c index d6be2f0..fc1be7d 100644 --- a/Src/subst.c +++ b/Src/subst.c @@ -2878,6 +2878,67 @@ paramsubst(LinkList l, LinkNode n, char **str, int qt, int pf_flags) } break; } + } else if (inbrace && (*s == '^' || *s == Hat)) { + char **zip, **ap, **apsrc; + int shortest = 1; + ++s; + if (*s == '^' || *s == Hat) { + shortest = 0; + ++s; + } + if (*itype_end(s, IIDENT, 0)) { + untokenize(s); + zerr("not an identifier: %s", s); + return NULL; + } + if (vunset) { + if (unset(UNSET)) { + *idend = '\0'; + zerr("%s: parameter not set", idbeg); + return NULL; + } + val = dupstring(""); + } else { + char *sval; + zip = getaparam(s); + if (!zip) { + sval = getsparam(s); + if (sval) + zip = hmkarray(sval); + } + if (!isarr) aval = mkarray(val); + if (zip) { + char **out; + int alen, ziplen, outlen, i = 0; + alen = arrlen(aval); + ziplen = arrlen(zip); + outlen = shortest ^ (alen > ziplen) ? alen : ziplen; + if (!shortest && (alen == 0 || ziplen == 0)) { + if (ziplen) + aval = arrdup(zip); + } else { + out = zhalloc(sizeof(char *) * (2 * outlen + 1)); + while (i < outlen) { + if (copied) + out[i*2] = aval[i % alen]; + else + out[i*2] = dupstring(aval[i % alen]); + out[i*2+1] = dupstring(zip[i % ziplen]); + i++; + } + out[i*2] = NULL; + aval = out; + copied = 1; + isarr = 1; + } + } else { + if (unset(UNSET)) { + zerr("%s: parameter not set", s); + return NULL; + } + val = dupstring(""); + } + } } else if (inbrace && (*s == '|' || *s == Bar || *s == '*' || *s == Star)) { int intersect = (*s == '*' || *s == Star); diff --git a/Test/D04parameter.ztst b/Test/D04parameter.ztst index a8cc93a..49dcea9 100644 --- a/Test/D04parameter.ztst +++ b/Test/D04parameter.ztst @@ -1560,3 +1560,79 @@ 0:Intersection and disjunction with empty parameters >0 >0 + + foo=(a b c) + bar=(1 2 3) + print ${foo:^bar} + print ${foo:^^bar} + foo=(a b c d) + bar=(1 2) + print ${foo:^bar} + print ${foo:^^bar} + foo=('a a' b) + bar=(1 '2 2') + print -l "${foo:^bar}" + print -l "${(@)foo:^bar}" +0:Zipping arrays, correct output +>a 1 b 2 c 3 +>a 1 b 2 c 3 +>a 1 b 2 +>a 1 b 2 c 1 d 2 +# maybe this should be changed to output "a a b 1" +>a a b +>1 +>a a +>1 +>b +>2 2 + + foo=(a b c) + bar=() + print ${foo:^bar} + print ${foo:^^bar} + print ${bar:^foo} + print ${bar:^^foo} + print ${bar:^bar} + print ${bar:^^bar} +0:Zipping arrays, one or both inputs empty +> +>a b c +> +>a b c +> +> + + foo=text + bar=() + print ${foo:^bar} + print ${bar:^^foo} + bar=other + print ${foo:^bar} + bar=(array elements) + print ${foo:^bar} + print ${foo:^^bar} + print ${bar:^foo} + print ${bar:^^foo} +0:Zipping arrays, scalar input +> +>text +>text other +>text array +>text array text elements +>array text +>array text elements text + + foo=(a b c) + print ${foo:^^^bar} +1:Zipping arrays, parsing +?(eval):2: not an identifier: ^bar + + (setopt nounset + print ${foo:^noexist}) +1:Zipping arrays, NO_UNSET part 1 +?(eval):2: noexist: parameter not set + + (setopt nounset + print ${noexist:^foo}) +1:Zipping arrays, NO_UNSET part 2 +?(eval):2: noexist: parameter not set -- 1.9.0