Language.PIR

Parrot PIR syntax tree.

   All that is gold does not glitter,
   Not all those who wander are lost;
   The old that is strong does not wither,
   Deep roots are not reached by the frost.

Documentation

type PIR = [Decl]

PIR code consists of declarations.

data Decl

Constructors

DeclSub

Subroutine declaration

Fields

dsName :: !SubName

dsFlags :: ![SubFlag]

dsBody :: ![Stmt]

DeclNS

Namespace declaration

Fields

dnPackage :: !PkgName

dnBody :: ![Decl]

DeclInc

.include directive

Fields

diFile :: !FilePath

DeclHLL

HLL directive

Fields

dhLang :: !String

dhGroup :: !String

Instances

Eq Decl

Show Decl

Typeable Decl

YAML Decl

Emit Decl

Emits PIR code for declarations (namespace, include, or sub declarations).

data Stmt

Constructors

StmtComment !String

Comment

StmtLine !FilePath !Int

#line directive

StmtPad ![(VarName, Expression)] ![Stmt]

Lexical Pad

StmtRaw !Doc

Backdoor into raw Doc

StmtIns !Ins

Generic instructions

StmtSub !SubName ![Stmt]

Inner subroutine

Instances

Eq Stmt

Show Stmt

Typeable Stmt

YAML Stmt

Emit Stmt

data Ins

Constructors

InsLocal !RegType !VarName

.local directive

InsNew !LValue !ObjType

new opcode

InsBind !LValue !Expression

set opcode

InsAssign !LValue !Expression

assign opcode

InsPrim !(Maybe LValue) !PrimName ![Expression]

Other opcodes

InsFun ![Sig] !Expression ![Expression]

Function call

InsTailFun !Expression ![Expression]

Tail call

InsLabel !LabelName

Label

InsComment !String !(Maybe Ins)

Comment

InsExp !Expression

Generic expressions

InsConst !LValue !ObjType !Expression

Constant

Instances

Eq Ins

Show Ins

Typeable Ins

YAML Ins

Emit Ins

data Expression

Constructors

ExpLV !LValue

Variables

ExpLit !Literal

Literals

Instances

Eq Expression

Show Expression

Typeable Expression

YAML Expression

Emit Expression

RegClass Expression

data LValue

Constructors

VAR !VarName

A variable declared by .local

PMC !Int

PMC register n

STR !Int

String register n

INT !Int

Integer register n

NUM !Int

Number register n

KEYED !LValue !Expression

Instances

Eq LValue

Show LValue

Typeable LValue

YAML LValue

Emit LValue

RegClass LValue

data Literal

Constructors

LitStr !String

A literal string

LitInt !Integer

A literal integer

LitNum !Double

A literal number

Instances

Eq Literal

Show Literal

Typeable Literal

YAML Literal

Emit Literal

Emits a literal (a LitStr, LitInt, or LitNum), and escapes if necessary.

data SubFlag

Tags a PIR subroutine definition with @MAIN, @LOAD, @ANON, @METHOD, or @MULTI.

Constructors

SubMAIN

SubLOAD

SubANON

SubMETHOD

SubMULTI ![ObjType]

SubOUTER !SubName

Instances

Eq SubFlag

Show SubFlag

Typeable SubFlag

YAML SubFlag

Emit SubFlag

Emits PIR code for a SubFlag (e.g. :main, :anon, etc.).

data RegType

Constructors

RegInt

I (Integer) register

RegNum

N (Number) register

RegStr

S (String) register

RegPMC

P (PMC) register

Instances

Eq RegType

Show RegType

Typeable RegType

YAML RegType

Emit RegType

data ObjType

A PMC type, which, for example, can be given as an argument to the new opcode (e.g. new .PerlScalar).

Constructors

PerlScalar

PerlArray

PerlHash

PerlInt

PerlPair

PerlRef

PerlEnv

Sub

Closure

Continuation

BareType String

Instances

Eq ObjType

Show ObjType

Typeable ObjType

YAML ObjType

Emit ObjType

Emits PIR code for an ObjType (e.g. .PerlScalar).

LiteralClass ObjType

type LabelName = String

type SubName = String

type VarName = String

type PrimName = String

type PkgName = String

type CallConv = String

emitStmts :: [Stmt] -> Doc

curPad :: Int

emitRets :: [Sig] -> Doc

emitFun :: (Emit b, Emit c) => CallConv -> b -> [c] -> [Sig] -> Doc

emitArgs :: Emit a => [a] -> Doc

emitFunName :: Emit b => CallConv -> String -> [b] -> [Sig] -> Doc

noArgs :: [Expression]

expKeyed :: LValue -> Expression -> Expression

quoted :: String -> String

include :: PkgName -> Decl

.include directive.

hll :: String -> String -> Decl

.HLL directive.

(<:=) :: LValue -> Expression -> Ins

Short for InsBind (binding).

(<==) :: LValue -> Expression -> Ins

Short for InsAssign.

(<--) :: LValue -> PrimName -> [Expression] -> Ins

Calls an opcode which returns a value.

(.-) :: PrimName -> [Expression] -> Ins

Calls an opcode, ignoring any return values.

(<-&) :: [Sig] -> Expression -> [Expression] -> Ins

Calls an user-defined sub which returns a list of values.

(.&) :: Expression -> [Expression] -> Ins

Calls an user-defined sub, ignoring any return values.

lit0 :: Expression

Literal zero

nullPMC :: RegClass a => a

$P0 register

funPMC :: RegClass a => a

$P1 register

rv :: RegClass a => a

$P2 register

arg0 :: RegClass a => a

$P10 register

arg1 :: RegClass a => a

$P11 register

arg2 :: RegClass a => a

$P12 register

arg3 :: RegClass a => a

$P13 register

tempPMC :: RegClass a => a

$P8 register

tempPMC2 :: RegClass a => a

$P9 register

tempSTR :: RegClass a => a

$S8 register

tempSTR2 :: RegClass a => a

$S9 register

tempSTR3 :: RegClass a => a

$S10 register

tempINT :: RegClass a => a

$I8 register

tempINT2 :: RegClass a => a

$I9 register

tempINT3 :: RegClass a => a

$I10 register

tempINT4 :: RegClass a => a

$I11 register

tempNUM :: RegClass a => a

$N8 register

tempNUM2 :: RegClass a => a

$N9 register

class RegClass y where

Methods

reg :: LValue -> y

Instances

RegClass Sig

RegClass LValue

RegClass Expression

class LiteralClass x where

Methods

lit :: x -> Expression

Instances

LiteralClass Bool

LiteralClass Double

LiteralClass Int

LiteralClass String

LiteralClass Doc

LiteralClass ObjType

LiteralClass [[ArgFlag]]

LiteralClass [ArgFlag]

sub

Arguments

:: SubName

Name of the subroutine

-> [Sig]

Signature

-> [Ins]

Subroutine body

-> Decl

The final subroutine declaration

Subroutine declaration.

sigList :: [Sig] -> [Expression]

data Sig

Constructors

MkSig

Fields

sigFlags :: [ArgFlag]

sigIdent :: Expression

Instances

Eq Sig

Show Sig

Typeable Sig

YAML Sig

RegClass Sig

data ArgFlag

Constructors

MkArgFlatten

MkArgSlurpyArray

MkArgMaybeFlatten

MkArgOptional

Instances

Eq ArgFlag

Show ArgFlag

Typeable ArgFlag

YAML ArgFlag

Emit [ArgFlag]

LiteralClass [[ArgFlag]]

LiteralClass [ArgFlag]

argVal :: ArgFlag -> Int

maybeFlatten :: Doc

slurpy :: Expression -> Sig

Marks a parameter as slurpy.

(-->) :: Decl -> [Expression] -> Decl

Returns from a sub.

retSigList :: [Expression] -> [Expression]

vop1

Arguments

:: SubName

Perl 6 name of the opcode to wrap

-> PrimName

PIR opcode

-> Decl

Final subroutine declaration

In the case a Perl 6 builtin corresponds exactly to a PIR opcode, you can use vop1 to create an appropriate wrapper for an opcode expecting one argument.

vop2

Arguments

:: SubName

Perl 6 name of the opcode to wrap

-> PrimName

PIR opcode

-> Decl

Final subroutine declaration

In the case a Perl 6 builtin corresponds exactly to a PIR opcode, you can use vop2 to create an appropriate wrapper for an opcode expecting two arguments.

vop2keyed

Arguments

:: SubName

Perl 6 name of the sub to create

-> LValue

Intermediate register to convert the index to (e.g. tempINT or tempSTR)

-> Decl

Final subroutine declaration

Creates a sub which accepts a thing which allows keyed access (for example aggregates) and an index.

vop1x

Arguments

:: SubName

Perl 6 name of the sub to create

-> PrimName

Opcode to wrap

-> (forall a. RegClass a => a)

Register to use for the return value of the op

-> (forall b. RegClass b => b)

Register type to convert the parameter to

-> Decl

Final subroutine declaration

Generic wrapper for unary opcodes.

vop1coerce

Arguments

:: SubName

Perl 6 name of the sub to create

-> (forall a. RegClass a => a)

Register type to convert the parameter to

-> Decl

Final subroutine declaration

Generic wrapper for coercion/context forcing (used by &prefix:<+>, &prefix:<~>, etc.)

vop2x

Arguments

:: SubName

Perl 6 name of the sub to create

-> PrimName

Opcode to wrap

-> (forall a. RegClass a => a)

Register to use for the return value of the op

-> (forall b. RegClass b => b)

Register type to convert the first parameter to

-> (forall c. RegClass c => c)

Register type to convert the second parameter to

-> Decl

Final subroutine declaration

Generic wrapper for two-ary opcodes.

vop1ii :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts and returns an I register.

vop1nn :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts and returns a N register.

vop1ss :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts and returns a S register.

vop1si :: SubName -> PrimName -> Decl

Wrapper for an opcode which returns a S register and accepts a I register.

vop1is :: SubName -> PrimName -> Decl

Wrapper for an opcode which returns a I register and accepts a S register.

vop1ip :: SubName -> PrimName -> Decl

Wrapper for an opcode which returns a I register and accepts a P register.

vop2iii :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts and returns I registers.

vop2nnn :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts and returns N registers.

vop2iss :: SubName -> PrimName -> Decl

Wrapper for an opcode which accepts two S registers and returns a native integer (I register).

bare :: VarName -> Expression

collectCC :: [Ins]

callThunkCC :: Expression -> [Ins]

stmtControlLoop

Arguments

:: VarName

Perl 6 name of the new sub

-> PrimName

PIR opcode to use for branching

-> Decl

Final declaration of the sub

Creates appropriate &statement_control:foo subroutines.

stmtControlCond

Arguments

:: VarName

Perl 6 name of the new sub

-> PrimName

PIR opcode to use for branching

-> Decl

Final declaration of the sub

Creates appropriate &statement_control:foo subroutines.

op2Logical

Arguments

:: VarName

Perl 6 name of the sub to create

-> PrimName

PIR opcode to use (if, unless)

-> Decl

Final declaration of the sub

Creates appropriate &infix:foo subs for logical operators (||, &&, etc.).

escaped :: String -> String

Escapes characters which have a special meaning in PIR.

preludePIR :: Doc

The Prelude, defining primitives like &say, &infix:+, etc.

Generated by DrIFT : Look, but Don't Touch. *

class Show x => Emit x where

Methods

emit :: x -> Doc

Instances

Emit Int

Emit String

Emit Doc

Emit ObjType

Emits PIR code for an ObjType (e.g. .PerlScalar).

Emit RegType

Emit SubFlag

Emits PIR code for a SubFlag (e.g. :main, :anon, etc.).

Emit Literal

Emits a literal (a LitStr, LitInt, or LitNum), and escapes if necessary.

Emit LValue

Emit Expression

Emit Ins

Emit Stmt

Emit Decl

Emits PIR code for declarations (namespace, include, or sub declarations).

Emit a => Emit [a]

Emit [ArgFlag]

Emit a => Emit (Maybe a)

nested :: Emit x => x -> Doc

eqSep :: (Emit a, Emit b, Emit c) => a -> b -> [c] -> Doc

commaSep :: Emit x => [x] -> Doc