Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/Raku/nqp

NQP
https://github.com/Raku/nqp

hacktoberfest raku

Last synced: about 2 months ago
JSON representation

NQP

Awesome Lists containing this project

README 

        
=pod



=head1 NQP - Not Quite Perl



NQP is Copyright (C) 2009-2020 by The Perl Foundation.  See F

for licensing details.



This is "Not Quite Perl" -- a lightweight Raku-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, raku or Rakudo) and is focused on

being a high-level way to create compilers and libraries for virtual

machines like L, the JVM, and others.



Unlike a full-fledged implementation of Raku, NQP strives to have as small

a runtime footprint as it can, while still providing a Raku object model

and regular expression engine for the virtual machine.



=head2 Building from source



=for HTML 



To build NQP from source, you'll just need a C utility and C 5.8 or

newer.  To automatically obtain and build MoarVM you may also need

a C client.



To obtain C directly from its repository:



    $ git clone git://github.com/Raku/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/Raku/nqp/tree/main and clicking

"Download".  Then unpack the tarball or zip.



C can run on three different backends: C, the C, and C.

The C and C backends are currently experimental.  The JVM backend

requires C (also known as C) or higher.



Once you have a copy of NQP, decide which backends you want to run,

and configure and build it as follows:



    $ cd nqp

    $ perl Configure.pl --with-moar=/path/to/moar --backends=moar,jvm

    $ make



If you don't have an installed MoarVM, you can have

C download and build one for you as well -- by passing the C<--gen-moar>

option to it (instead of C<--with-moar>):



    $ cd nqp

    $ perl Configure.pl --gen-moar --backends=moar,jvm

    $ make



The C step will create a C or C 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 MoarVM executable and installs to the

directory C<./install>.  You can change that with the C<--prefix> option to

Configure.pl; this will point to the directory prefix where `moar` is installed,

such as `/usr`; it needs to be the same one used when configuring MoarVM unless

you use the option `--with-moar`.  This optional argument should point to the installed

`moar` executable; for instance, `--with-moar=/usr/local/bin/moar`.



Once built, NQP's C target will install NQP and its libraries

into the same location as the MoarVM installation

that was used to create it.  Until this step is

performed, the C executable created by C above can only be

reliably run from the root of NQP's build directory.  After C

is performed the executable can be run from any directory.



If the C 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



=head3 OS X



On OS X, it appears that configuration fails in some configurations:



  3rdparty/libuv/include/uv-darwin.h:26:11: fatal error: 'mach/mach.h' file not found



Should this happen to you, then a solution might be the following:



    $ cd MoarVM/3rdparty/libuv/include

    $ ln -s /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk/usr/include/mach

    $ cd ../../../..

    $ # run the Configure again



Note that the 10.9 in the above, represents the major version of OS X being

used.  On Mavericks use 10.9 (like above), on Yosemite use 10.10.



=head3 JVM



If attempting to run NQP on the JVM results in NQP claiming it couldn't reserve

enough memory, you may need to increase the memory limit of your shell like so:



    $ ulimit -d 6144000



=head2 Using NQP



B there's B for NQP and the behaviour can

change without notice. It's a tool for writing Raku compilers, not a

low-level module for Raku programmers.



The L is a good place to start, with the

L and other files. Opcodes are listed in

L. NQP also has built-in routines

listed in L. You can use NQP from this

release, it will be already installed if you have built Raku from

scratch.



=head2 JavaScript backend



The best thing before playing with it/hacking on it is to contact pmurias via IRC at C<#raku> on L.

We depend on C at least 10.10.0



Building the JavaScript backend currently requires building the moar backend:



    $ perl Configure.pl --backends=moar,js

    $ make



Currently it needs to be run like:



    $ ./nqp-js file.nqp



If you are developing C, you may want to pass the C<--link> option to configure to have the C linked instead of installed



    $ cd src/vm/js/nqp-runtime; npm link .

    $ perl Configure --backends=moar,js



=cut