Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
PARROT(1)	      User Contributed Perl Documentation	     PARROT(1)

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:

	     fast	    bare-bones core without bounds-checking or
			    context-updating (default)

	     slow, bounds   bounds checking core

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

	     profiling	    see	F<docs/dev/profiling.pod>

	     subprof	    subroutine-level profiler
			    (see POD in	F<src/runcore/subprof.c>)

       -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
       -O[level]
	   Valid optimizer levels: "-O", "-O1",	"-O2", "-Op"

	   -O1 enables the pre_optimizer, runs before control flow graph (CFG)
	   is built.  It includes strength reduction and rewrites certain
	   if/branch/label constructs.

	   -O2 runs afterwards,	handles	constant propagation, jump
	   optimizations, removal of unused labels and dead code.

	   -Op applies -O2 to pasm files also.

	   The old options -Oc (tailcall) and -Oj are currently	ineffective.

	   -O defaults to -O1.

       -d[=HEXFLAGS]
       --imcc-debug[=HEXFLAGS]
	   Turn	on compiler debug flags.  See "parrot --help-debug" for
	   available flag bits.

       -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.
       -v
       --verbose      Turn on compiler verbosity.

   <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-2014,	Parrot Foundation.

perl v5.32.1			  2016-02-15			     PARROT(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | ENVIRONMENT | SEE ALSO | REPORTING BUGS | AUTHORS | COPYRIGHT

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=parrot&sektion=1&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help