Implementing Perl 6 Jonathan Worthington Dutch Perl Workshop 2008
Implementing Perl 6 I didn’t know I was giving this talk until yesterday.
Implementing Perl 6 I could have written my slides last night, but…
Implementing Perl 6
Implementing Perl 6 Guess what will be released at Christmas?*
Implementing Perl 6 Guess what will be released at Christmas?* * Which Christmas not specified.
Implementing Perl 6 Perl 6!
Implementing Perl 6 Introducing Rakudo � Name of the Perl 6 compiler targeting the Parrot Virtual Machine � Parts written in Perl 6 � Parser written using Perl 6 regexes (now known as rules) � Parser actions (more later) written in subset of Perl 6 called NQP � Other bits in Parrot Intermediate Repr.
Implementing Perl 6 Compiler Architecture
Implementing Perl 6 Parrot Compiler Tools � PCT is a tool chain for building compilers � You write the "front end": � Grammar, which specifies syntax � Actions, which produce an Abstract Syntax Tree from the Parse Tree � The backend (from the AST down to Parrot bytecode) is done for you
Implementing Perl 6 Compilation Process Program Source Parse Tree Abstract Syntax Tree Opcode Syntax Tree PIR (Parrot IL) Parrot Bytecode
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 PGE = Parrot Grammar Engine � Implementation of Perl 6 regexes � Can name regexes and call them from each other (recursively too) regex Year { \d**4 }; regex Place { Ukrainian | Dutch | German }; regex Workshop { <Place> \s Perl \s Workshop \s <Year> }; regex YAPC { 'YAPC::' ['EU'|'NA'|'Asia'] \s <Year> }; regex PerlEvent { <Workshop> | <YAPC> };
Implementing Perl 6 PGE = Parrot Grammar Engine � You use PGE to write the grammar for your language rule unless_statement { 'unless' <EXPR> <block> {*} } � You put a {*} in place to indicate that we should run an action
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 NQP = Not Quite Perl 6 � A subset of Perl 6 � Contains just enough to allow you to produce an Abstract Syntax Tree from the parse tree � Variables and literals � Binding (but not assignment) � Conditionals and loops � Object instantiation and method calls
Implementing Perl 6 NQP = Not Quite Perl 6 � This method is called when the parser encounters the {*} in the grammar method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � We are passed $/, the match object, which describes what was parsed method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � Named captures ($<….>) give you the match object for the sub rules method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � Writing $( $<…> ) gets you the AST for that match object method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � We instantiate a new AST node of type Op method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � This node has two children: the condition and the block to run method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � Also specify the type of operation; PCT will then generate the appropriate code method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � Also specify the match object that we made this from, for line numbers etc. method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 NQP = Not Quite Perl 6 � The "make" statement specifies the tree node we have made method unless_statement($/) { my $then := $( $<block> ); $then.blocktype('immediate'); my $past := PAST::Op.new( $( $<EXPR> ), $then, :pasttype('unless'), :node( $/ ) ); make $past; }
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 PAST to POST � POST is the Parrot Opcode Syntax Tree � Tree representation of Parrot assembly program � Often one node = one instruction � The PAST compiler, part of PCT, transforms a PAST node into (usually many) POST nodes
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 POST to PIR � PIR = Parrot Intermediate Representation � Text based rather than tree based � The Parrot VM itself understands PIR, so for now we have to turn the POST tree into PIR � One day, we may be able to go direct from the tree to the bytecode
Implementing Perl 6 Compilation Process Program Source PGE Parse Tree NQP Abstract Syntax Tree PCT Opcode Syntax Tree PCT PIR (Parrot IL) Parrot Parrot Bytecode
Implementing Perl 6 PIR to Parrot Bytecode � The Parrot VM actually executes bytecode – a binary representation of the program � It contains a compiler that turns PIR into Parrot Bytecode � We can write the bytecode to disk so we can load it again in the future => don't need to compile our program every time => performance!
Implementing Perl 6 The Perl 6 Grammar
Implementing Perl 6 STD.pm � STD.pm is the standard Perl 6 grammar, written in Perl 6 rules � Mostly complete, though we find missing things occasionally � PGE doesn't support all of the syntax it uses yet, so we don't use it as is; instead, import it bit by bit and tweak it � End goal is that they will converge
Implementing Perl 6 Two Parsers In One � Use bottom-up parsing for expressions and top-down parsing for the rest � Have to call between them � When top-down parser needs an expression, uses <EXPR> to call into bottom-up parser to get one � If it needs a term, uses <term> to call into the top-down parser to get one
Implementing Perl 6 Top-down Parser � Defined using token, rule and regex Backtracking Sigspace ����� ����� ����� ����� yes no ����� ����� ����� ����� no no ���� ���� ���� ���� no yes � sigspace means replace any whitespace in the pattern with <.ws>, which is the current language's whitespace rule
Implementing Perl 6 Bottom-up Parser � We specify the operators in the expression grammar, for bottom up parsing ## multiplicative operators proto infix:<*> is precedence('u=') { ... } proto infix:</> is equiv(infix:<*>) { ... } proto infix:<%> is equiv(infix:<*>) { ... } ## additive operators proto infix:<+> is precedence('t=') { ... } proto infix:<-> is equiv(infix:<+>) { ... }
Implementing Perl 6 Implementing Built-ins
Implementing Perl 6 Implementing Operators � In Perl 6, an operator is just a (multi- dispatch) sub called with special syntax � Operator implemented in PIR .sub 'infix:+' :multi(_,_) .param pmc a .param pmc b $P0 = n_add a, b .return ($P0) .end
Recommend
More recommend
