Fix up usage of openpipe()/shell()

Author: hoelzro

Configure.pl

@@ -108,7 +108,8 @@
 
     my $launcher = $prefixes{$default_backend} . '-runner-default';
     print $MAKEFILE "all: ", join(' ', map("$_-all", @prefixes), $launcher), "\n";
-    for my $t (qw/clean test qregex-test install/) {
+    print $MAKEFILE "install: ", join(' ', map("$_-install", @prefixes), $launcher . '-install'), "\n";
+    for my $t (qw/clean test qregex-test/) {
         print $MAKEFILE "$t: ", join(' ', map "$_-$t", @prefixes), "\n";
     }
 
@@ -220,7 +221,8 @@
                 "(You can get a MoarVM built automatically with --gen-moar.)";
         }
         sorry(@errors) if @errors;
-        $config{'make'}   = $^O eq 'MSWin32' ? 'nmake' : 'make';
+        $config{'make'} = `$moar_path --libpath="src/vm/moar/stage0" "src/vm/moar/stage0/nqp.moarvm" -e "print(nqp::backendconfig()<make>)"`
+                        || 'make';
         $config{moar} = $moar_path;
         fill_template_file(
             'tools/build/Makefile-Moar.in',

README.pod

@@ -3,15 +3,14 @@
 NQP is Copyright (C) 2009-2015 by The Perl Foundation.  See F<LICENSE>
 for licensing details.
 
-This is "Not Quite Perl" -- a lightweight Perl 6-like environment
-for virtual machines.  The key feature of NQP is that it's
-designed to be a very small environment (as compared with, say, perl6
-or Rakudo) and is focused on being a high-level way to create
-compilers and libraries for virtual machines (such as the Parrot
-Virtual Machine [1], the JVM, and MoarVM [2]).  Unlike a full-fledged
-implementation of Perl 6, NQP strives to have as small a runtime footprint
-as it can, while still providing a Perl 6 object model and regular expression
-engine for the virtual machine.
+This is "Not Quite Perl" -- a lightweight Perl 6-like environment for
+virtual machines.  The key feature of NQP is that it's designed to be a very
+small environment (as compared with, say, perl6 or Rakudo) and is focused on
+being a high-level way to create compilers and libraries for virtual
+machines (such as the Parrot Virtual Machine [1], the JVM, and MoarVM [2]).
+Unlike a full-fledged implementation of Perl 6, NQP strives to have as small
+a runtime footprint as it can, while still providing a Perl 6 object model
+and regular expression engine for the virtual machine.
 
     [1] http://parrot.org/
     [2] https://github.com/MoarVM/MoarVM
@@ -20,56 +19,55 @@ engine for the virtual machine.
 
 =for HTML <a href="https://travis-ci.org/perl6/nqp"><img src="https://travis-ci.org/perl6/nqp.svg?branch=master"></a>
 
-To build NQP from source, you'll just need a C<make> utility
-and Perl 5.8 or newer.  To automatically obtain and build Parrot
-you may also need a git client.
+To build NQP from source, you'll just need a C<make> utility and Perl 5.8 or
+newer.  To automatically obtain and build Parrot you may also need a git
+client.
 
 To obtain NQP directly from its repository:
 
     $ git clone git://github.com/perl6/nqp.git
 
-If you don't have git installed, you can get a tarball or zip
-of NQP from github by visiting http://github.com/perl6/nqp/tree/master
-and clicking "Download".  Then unpack the tarball or zip.
+If you don't have git installed, you can get a tarball or zip of NQP from
+github by visiting http://github.com/perl6/nqp/tree/master and clicking
+"Download".  Then unpack the tarball or zip.
 
 NQP can run on three different backends: Parrot, MoarVM and the Java Virtual
-Machine (JVM). Decide on which backends you want it to run, and configure and
-build it as follows:
+Machine (JVM). Decide on which backends you want it to run, and configure
+and build it as follows:
 
 Once you have a copy of NQP, build it as follows:
 
     $ cd nqp
     $ perl Configure.pl --backends=moar,parrot,jvm
     $ make
 
-If you don't have parrot installed, you can have Configure.pl generate one for
-you by passing the C<--gen-parrot> option to it as well.  If you don't have
-MoarVM installed, you can have Configure.pl generate one for you by passing
-the C<--gen-moar> option to it as well.
+If you don't have parrot installed, you can have Configure.pl generate one
+for you by passing the C<--gen-parrot> option to it as well.  If you don't
+have MoarVM installed, you can have Configure.pl generate one for you by
+passing the C<--gen-moar> option to it as well.
 
-The C<make> step will create a "nqp" or "nqp.exe" executable in the
-current directory.  Programs can then be run from the build 
-directory using a command like:
+The C<make> step will create a "nqp" or "nqp.exe" executable in the current
+directory.  Programs can then be run from the build directory using a
+command like:
 
     $ ./nqp hello.nqp
 
 By default, NQP searches for the parrot executable and installs to the
 directory C<./install>. You can change that with the C<--prefix> option to
 Configure.pl.
 
-Once built, NQP's C<make install> target will install NQP
-and its libraries into the Parrot installation that was used to
-create it.  Until this step is performed, the "nqp" executable
-created by C<make> above can only be reliably run from the root of
-NQP's build directory.  After C<make install> is performed
-the executable can be run from any directory (as long as the
+Once built, NQP's C<make install> target will install NQP and its libraries
+into the Parrot installation that was used to create it.  Until this step is
+performed, the "nqp" executable created by C<make> above can only be
+reliably run from the root of NQP's build directory.  After C<make install>
+is performed the executable can be run from any directory (as long as the
 Parrot installation that was used to create it remains intact).
 
-If the NQP compiler is invoked without an explicit script to
-run, it enters a small interactive mode that allows statements
-to be executed from the command line.  Each line entered is treated
-as a separate compilation unit, however (which means that subroutines
-are preserved after they are defined, but variables are not).
+If the NQP compiler is invoked without an explicit script to run, it enters
+a small interactive mode that allows statements to be executed from the
+command line.  Each line entered is treated as a separate compilation unit,
+however (which means that subroutines are preserved after they are defined,
+but variables are not).
 
 =head2 Troubleshooting
 
@@ -91,13 +89,12 @@ used.  On Mavericks use 10.9 (like above), on Yosemite use 10.10.
 
 =head2 Differences from nqp-rx
 
-NQP is the successor implementation of "nqp-rx" [2].  Unlike nqp-rx,
-which aimed to have almost no runtime component whatsoever, this new
-version of NQP accepts that a minimal Perl 6 object metamodel,
-multidispatcher, and regular expression engine are needed on top of
-the underlying virtual machine.  Also, nqp-rx only ran on Parrot,
-whereas NQP also runs on the JVM and MoarVM and is designed to be
-portable to more.
+NQP is the successor implementation of "nqp-rx" [2].  Unlike nqp-rx, which
+aimed to have almost no runtime component whatsoever, this new version of
+NQP accepts that a minimal Perl 6 object metamodel, multidispatcher, and
+regular expression engine are needed on top of the underlying virtual
+machine.  Also, nqp-rx only ran on Parrot, whereas NQP also runs on the JVM
+and MoarVM and is designed to be portable to more.
 
     [2] http://github.com/perl6/nqp-rx
 

VERSION

@@ -1 +1 @@
-2015.01
+2015.07.2

docs/6model/repr-compose-protocol.markdown

@@ -87,12 +87,27 @@ A hash that may have the following keys:
   each element. Again, this is just about layout and lookup, not about type
   checking.
 
+* dimensions - the number of dimensions an array of this type supports. A
+  given REPR may be restricted to only support a single dimensions.
+
 ## hash
 
+A hash that may have the following keys:
+
 * valuetype - the type of the hash value. As with arrays, it's up to the REPR
   how or if it handles native types. Just about layout.
 
 * keytype - the type of the hash key. REPRs are likely to be restrictive here,
   since they need to understand the representation of the provided key well
   enough to hash it. This will probably mean strings and whatever REPR ObjAt
   in Perl 6 (or some other language's variant) has.
+
+## nativeref
+
+A hash that must have the following two keys:
+
+* type - the native type that is being referenced. Must have a storage spec
+  that claims to be a native int/num/str.
+
+* refkind - the kind of reference, specified as a string. Must be one of
+  'attribute', 'positional', or 'lexical'.