NAME

       parrot - Parrot Virtual Machine

SYNOPSIS

       parrot [-options] <file> [arguments ...]

DESCRIPTION

       Parrot is a virtual machine designed to efficiently compile and execute bytecode for
       dynamic languages. Parrot currently hosts a variety of language implementations in various
       stages of completion, including Tcl, Javascript, Ruby, Lua, Scheme, PHP, Python, Perl 6,
       APL, and a .NET bytecode translator.  Parrot is not about parrots, but we are rather fond
       of them, for obvious reasons.

OPTIONS

       -h
       --help         Print the option summary on the command line.
       -V
       --version      Print version information and exit.
       -I
       --include      Add "path" to the include search path.
       -L
       --library      Add "path" to the library search path.
       --hash-seed [hexnum]
           Sets the hash seed to the specified value. This option is useful for debugging
           intermittent failures, but should not be used in production.  For more information
           about this option, see docs/dev/profiling.pod, docs/project/hacking_tips.pod,
           docs/running.pod, and docs/submissions.pod.

       -X
       --dynext       Add "path" to the dynamic extension search path.

   Run core options
       These options select the runcore, which is useful for performance tuning and debugging.
       For more information about these options, see the "About runcores" section in
       docs/running.pod.

       -R
       --runcore [CORE]
           Select the runcore. The following cores are available in Parrot, but not all may be
           available on your system:

             slow, bounds   bounds checking core (default)

             fast           bare-bones core without bounds-checking or
                            context-updating

             subprof        subroutine-level profiler
                            (see POD in 'src/runcore/subprof.c')

             trace          bounds checking core with trace info
                            (see 'parrot --help-debug')

             profiling      see 'docs/dev/profilling.pod'

             gcdebug        performs a full GC run before every op dispatch
                            (good for debugging GC problems)

       -p
       --profile      Run with the slow core and print an execution profile.
       -t
       --trace        Run with the slow core and print trace information to stderr.
           See "parrot --help-debug" for available flag bits.

   VM options
       -D
       --parrot-debug[=HEXFLAGS]
           Turn on interpreter debug flag.  See "parrot --help-debug" for available flag bits.

       --help-debug   Print the summary of debugging and tracing flag bits.
       -w
       --warnings     Turn on warnings.
           See "parrot --help-debug" for available flag bits.

       -G
       --no-gc        Turn off GC.
           This may prove useful for finding GC-related bugs.

           Note:      Do not use this option for longer running programs: since memory is no
                      longer recycled, it may quickly become exhausted.

       -g
       --gc [GC-type]

       GC MS2 options

       --gc-dynamic-threshold=percentage
           Maximum memory wasted by GC

       --gc-min-threshold=Kb

       GC GMS options

       --gc-nursery-size=percent of system
           Size of gen0 (default 2)

       --gc-debug     Turn on GC (Garbage Collection) debugging.
           This imposes some stress on the GC subsystem and can considerably slow down execution.

       --leak-test|--destroy-at-end
           Free all memory of the last interpreter.  This is useful when running leak checkers.

       -.
       --wait         Read a keystroke before starting.
           This is useful when you want to attach a debugger on platforms such as Windows.

       --runtime-prefix
           Print the runtime prefix path and exit.

       --numthreads <number>
           Overrides the automatically detected number of CPU cores to set the number of OS
           threads. Minimum number: 2

   Compiler options
       -E
       --pre-process-only
           Preprocess source file (expand macros) and print result to "stdout":

             $> parrot -E t/op/macro_10.pasm
             $> parrot -E t/op/macro_10.pasm | parrot -- -

       -o
       --output=FILE  Act like an assembler, but do not execute the code,
           unless the -r is supplied as well. If 'outputfile' ends with .pbc, 'parrot' will write
           a PBC file. If it ends with .pasm, 'parrot' will output a PASM file, even from PASM
           input.

       --output-pbc   Act like an assembler, but always output bytecode,
           even if the output file does not end in .pbc

       -a
       --pasm         Assume PASM input on "stdin".
       -c
       --pbc          Assume PBC file on "stdin" and execute it.
           NOTE: If whitespace separates the -d switch from the argument, the argument must start
           with a number, i.e., a decimal digit.

       -r
       --run-pbc      Only useful after "-o" or "--output-pbc".
           Execute the program from the compiled in-memory image. If two "-r" options are
           supplied, the .pbc file is read from disc and executed. This is needed, primarily, for
           tests.

       -y
       --yydebug      Turn on yydebug in yacc/bison.

   <file>
       If the file ends in .pbc it will be interpreted immediately.

       If the file ends in .pasm, then it is parsed as PASM code. Otherwise, it is parsed as PIR
       code. In both cases, it will then be executed, unless the "-o" flag was supplied.

       If the "file" is a single dash, input from "stdin" is read.

   [arguments ...]
       Optional arguments passed to the running program as ARGV. The program is assumed to know
       what to do with the arguments.

ENVIRONMENT

       PARROT_RUNTIME
           If this environment variable is set, parrot will use this path as its runtime prefix
           instead of the compiled-in path.  This is useful if you want to execute a version of
           parrot different from the one on the "compiled-in" path.

       PARROT_GC_DEBUG
           Turn on the --gc-debug flag.

SEE ALSO

       'docs/running.pod'           Additional information on command line options.

       http://www.parrot.org/       The official Parrot web site.

       http://docs.parrot.org/      Parrot's official documentation site.

       http://parrot.github.com/    An alternative documentation site.

REPORTING BUGS

       For information on how to submit a bug report, see docs/submissions.pod.

AUTHORS

       Parrot is a product of the contributions of a great many people.  For a list of most of
       these people, see CREDITS.

COPYRIGHT

       Copyright (C) 2001-2012, Parrot Foundation.