[svn:parrot] r48123 - in trunk/examples/languages/squaak: . doc src src/Squaak
tcurtis at svn.parrot.org
tcurtis at svn.parrot.org
Tue Jul 20 09:04:21 UTC 2010
Author: tcurtis
Date: Tue Jul 20 09:04:20 2010
New Revision: 48123
URL: https://trac.parrot.org/parrot/changeset/48123
Log:
Satisfy codetest.
Modified:
trunk/examples/languages/squaak/PARROT_REVISION (props changed)
trunk/examples/languages/squaak/doc/tutorial_episode_1.pod
trunk/examples/languages/squaak/doc/tutorial_episode_3.pod
trunk/examples/languages/squaak/doc/tutorial_episode_4.pod
trunk/examples/languages/squaak/doc/tutorial_episode_5.pod
trunk/examples/languages/squaak/doc/tutorial_episode_6.pod
trunk/examples/languages/squaak/doc/tutorial_episode_7.pod
trunk/examples/languages/squaak/setup.pir
trunk/examples/languages/squaak/squaak.pir
trunk/examples/languages/squaak/src/Squaak/Actions.pm (contents, props changed)
trunk/examples/languages/squaak/src/Squaak/Compiler.pm (contents, props changed)
trunk/examples/languages/squaak/src/Squaak/Grammar.pm (contents, props changed)
trunk/examples/languages/squaak/src/Squaak/Runtime.pm (contents, props changed)
trunk/examples/languages/squaak/src/squaak.pir (contents, props changed)
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_1.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_1.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_1.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -103,7 +103,9 @@
NQP is a lightweight language inspired by Perl 6 and can be used to write the
methods that must be executed during the parsing phase, just as you can write
-actions in a Yacc/Bison input file. It also provides the regular expression engine we'll use to write our grammar. In addition to the capabilities of Perl 5's regexes, the Perl 6 regexes that NQP implements can be used to define language grammars. (Check the references for the specification.)
+actions in a Yacc/Bison input file. It also provides the regular expression engine we'll use to
+write our grammar. In addition to the capabilities of Perl 5's regexes, the Perl 6 regexes that NQP
+ implements can be used to define language grammars. (Check the references for the specification.)
=item B<P>arrot B<A>bstract B<S>yntax B<T>ree (PAST).
@@ -158,7 +160,9 @@
$ ./installable_squaak test.sq
-"installable_squaak" is a "fake-cutable" an executable that bundles the Parrot interpreter and the compiled bytecode for a program to allow treating a Parrot program as a normal executable program. This will run Parrot, specifying squaak.pbc as the file to be run by Parrot,
+"installable_squaak" is a "fake-cutable" an executable that bundles the Parrot interpreter and the
+compiled bytecode for a program to allow treating a Parrot program as a normal executable program.
+This will run Parrot, specifying squaak.pbc as the file to be run by Parrot,
which takes a single argument: the file test.sq. If all went well, you should
see the following output:
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_3.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_3.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_3.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -163,7 +163,8 @@
<stat_or_def>*
}
-When you work on the action methods later, you'll also want to replace $<statement> in the action method with $<stat_or_def>
+When you work on the action methods later, you'll also want to replace $<statement> in the action
+method with $<stat_or_def>
Add these rules:
@@ -263,8 +264,8 @@
Now we have implemented the initial version of the Squaak grammar, it's time to
implement the parse actions we mentioned before. The actions are written in a
file called F<src/Squaak/Actions.pm>. If you look at the methods in this file,
-here and there you'll see that the C<ast> method being called on the match object ($/) , or rather, hash fields of
-it (like $<statement>).
+here and there you'll see that the C<ast> method being called on the match object ($/) , or rather,
+hash fields of it (like $<statement>).
The special make function can be used to set the ast to a value.
This means that each node in the parse tree (a Match object) can also hold its
PAST representation. Thus we use the make function to set the PAST
@@ -331,7 +332,8 @@
=item 5.
-Write the action method for stat_or_def. Simply retrieve the result object from statement and make that the result object.
+Write the action method for stat_or_def. Simply retrieve the result object from statement and make
+that the result object.
=item 6.
@@ -432,7 +434,8 @@
=item 5
-Write the action method for stat_or_def. Simply retrieve the result object from statement and make that the result object.
+Write the action method for stat_or_def. Simply retrieve the result object from statement and make
+that the result object.
method stat_or_def {
make $<statement>.ast;
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_4.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_4.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_4.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -60,10 +60,16 @@
The first statement we're going to implement now is the if-statement. An
if-statement has typically three parts (but this of course depends on the
programming language): a conditional expression, a "then" part and an "else"
-part. Implementing this in Perl 6 rules and PAST is almost trivial, but first, let's add a little infrastructure to simplify adding new statement types. Replace the statement rule with the following:
+part. Implementing this in Perl 6 rules and PAST is almost trivial, but first, let's add a little
+infrastructure to simplify adding new statement types. Replace the statement rule with the
+following:
proto rule statement { <...> }
-Delete the statement method from Action.pm, and rename the assignment rule in both Grammar.pm and Actions.pm to statement:sym<assignment>. The new statement rule is a "proto" rule. A proto rule is equivalent to a normal rule whose body contains each specialization of the rule separated by the | operator. The name of a particular specialization of a proto rule is placed between the angle brackets. Within the body of the rule, it can be matched literally with <sym>.
+Delete the statement method from Action.pm, and rename the assignment rule in both Grammar.pm and
+Actions.pm to statement:sym<assignment>. The new statement rule is a "proto" rule. A proto rule is
+equivalent to a normal rule whose body contains each specialization of the rule separated by the |
+operator. The name of a particular specialization of a proto rule is placed between the angle
+brackets. Within the body of the rule, it can be matched literally with <sym>.
rule statement:sym<if> {
<sym> <EXPR> 'then' $<then>=<block>
@@ -75,12 +81,15 @@
<statement>*
}
-Note that the optional else block is stored in the match object's "else" field, and the then block is stored in the match object's "then" field.
+Note that the optional else block is stored in the match object's "else" field, and the then block
+is stored in the match object's "then" field.
If we hadn't written this $<else>= part, then <block> would have been an array,
with block[0] the "then" part, and block[1] the optional else part. Assigning
the optional else block to a different field, makes the action method slightly
easier to read.
-Note that the proto declaration for statement means that the result object for $<statement> in any rule which calls statement as a subrule will be result object for whichever statement type matched. Because of this, we can delete the statement action method.
+Note that the proto declaration for statement means that the result object for $<statement> in any
+rule which calls statement as a subrule will be result object for whichever statement type matched.
+Because of this, we can delete the statement action method.
The relevant action methods are shown below:
method block($/) {
@@ -124,9 +133,9 @@
Have another look at the action method statement:sym<if>. In the first two lines,
we request the result objects for the conditional expression and the "then"
block. When were these result objects created? How can we be sure they're there?
-The answer lies in the order in which the parse actions are executed. The parse action invocation usually occurs
-at the end of the rule. For this input string: "if 42 then x = 1 end" this
-implies the following order:
+The answer lies in the order in which the parse actions are executed. The parse action invocation
+usually occurs at the end of the rule. For this input string: "if 42 then x = 1 end" this implies
+the following order:
=over 4
@@ -354,7 +363,8 @@
conditional expression, which represent the "then" block, and which represent
the "else" block (if any).
-Note that this may not be the exact result produced when you try it. Sub ids, block numbers, and register numbers may differ, but it should be analogous.
+Note that this may not be the exact result produced when you try it. Sub ids, block numbers, and
+register numbers may differ, but it should be analogous.
> if 1 then else end
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_5.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_5.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_5.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -156,7 +156,9 @@
<?>
}
-It uses something we haven't seen before, <?>. The null pattern <?> always returns true without consuming any text. Tokens consisting of only <?> are frequently used to invoke additional action methods.
+It uses something we haven't seen before, <?>. The null pattern <?> always returns true without
+consuming any text. Tokens consisting of only <?> are frequently used to invoke additional action
+methods.
Add this method to Actions.pm:
@@ -181,7 +183,8 @@
unshift method puts its argument on the front of the list. In a sense, you
could think of the front of this list as the top of a stack. Later we'll see
why this stack is necessary. This C<@?BLOCK> variable is also declared with "our", meaning it's also
-package-scoped. Since it's an array variable, it is automatically initialized with an empty ResizablePMCArray.
+package-scoped. Since it's an array variable, it is automatically initialized with an empty
+ResizablePMCArray.
Now we need to modify our TOP rule to call begin_TOP.
@@ -191,7 +194,9 @@
[ $ || <.panic: "Syntax error"> ]
}
-"<.begin_TOP>" is just like <begin_TOP>, calling the subrule begin_TOP, with one difference: The <.subrule> form does not capture. Normally, when match a subrule <foo>, $<foo> on the match object is bound to the subrule's match result. With <.foo>, $<foo> is not bound.
+"<.begin_TOP>" is just like <begin_TOP>, calling the subrule begin_TOP, with one difference: The
+<.subrule> form does not capture. Normally, when match a subrule <foo>, $<foo> on the match object
+is bound to the subrule's match result. With <.foo>, $<foo> is not bound.
The parse action for begin_TOP is executed before any input
is parsed, which is particularly suitable for any initialization actions you
@@ -270,10 +275,11 @@
The block rule, which defines a block to be a series of statements, represents
a new scope. This rule is used in for instance if-statement
(the then-part and else-part), while-statement (the loop body) and others.
-Add a new begin_block rule consisting of <?>; in the action for it, create a new PAST::Block and store it onto the scope stack.
+Add a new begin_block rule consisting of <?>; in the action for it, create a new PAST::Block and
+store it onto the scope stack.
Update the rule for block so that it calls begin_block before parsing
-the statements. Update the parse action for block after parsing the statements, during which this PAST node
-is set as the result object. Make sure C<$?BLOCK> is always pointing to the
+the statements. Update the parse action for block after parsing the statements, during which this
+PAST node is set as the result object. Make sure C<$?BLOCK> is always pointing to the
current block. In order to do this exercise correctly, you should understand
well what the shift and unshift methods do, and why we didn't implement methods
to push and pop, which are more appropriate words in the context of a (scope)
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_6.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_6.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_6.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -90,9 +90,12 @@
| <sub_definition>
}
-Appropriately modifying the action method is simple. It's analogous to the action method for expression.
+Appropriately modifying the action method is simple. It's analogous to the action method for
+expression.
-"**" is the repetition specifier; "<identifier> ** ','" matches <identifier> separated by commas. Since it's in a rule and there is space between the ** and its operands, whitespace is allowed between the commas and both the preceding and following identifiers.
+"**" is the repetition specifier; "<identifier> ** ','" matches <identifier> separated by commas.
+Since it's in a rule and there is space between the ** and its operands, whitespace is allowed
+between the commas and both the preceding and following identifiers.
This is rather straightforward, and the action methods for these rules are
quite simple, as you will see. First, however, let's have a look at the rule
@@ -420,8 +423,8 @@
$body.push($step);
-The loop condition uses the isle opcode, which checks that its first operand is less than or equal to its second, and compares the loop variable
-with the maximum value that was specified.
+The loop condition uses the isle opcode, which checks that its first operand is less than or equal
+to its second, and compares the loop variable with the maximum value that was specified.
## while loop iterator <= end-expression
my $cond := PAST::Op.new( :pirop<isle__IPP>,
Modified: trunk/examples/languages/squaak/doc/tutorial_episode_7.pod
==============================================================================
--- trunk/examples/languages/squaak/doc/tutorial_episode_7.pod Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/doc/tutorial_episode_7.pod Tue Jul 20 09:04:20 2010 (r48123)
@@ -124,20 +124,31 @@
<EXPR>
Of course, the optable must be populated with some operators that
-we need to be able to parse and it might be told what precedence and associativity they have. The easiest way to do this is by setting up precedence levels in an C<INIT> block:
+we need to be able to parse and it might be told what precedence and associativity they have. The
+easiest way to do this is by setting up precedence levels in an C<INIT> block:
INIT {
Squaak::Grammar.O(':prec<t>, :assoc<left>', '%additive');
Squaak::Grammar.O(':prec<u>, :assoc<lefT>', '%multiplicative');
}
-In this C<INIT> block, we use the C<O> method of the compiler to set up two precedence levels: one for operators like addition (named C<%additive>), and one for operators like multiplication (named C<%multiplicative>). Each of themhas a ":prec" value and an ":assoc" value. ":prec" determines the precedence. Lexicographically greater values indicate higher precedence, so C<%additive> operators, with a precedence value of "t", have lower precedence than C<%multiplicative> operators with a precedence value of "u".":assoc" defines the associativity of the operators. If C<@> is a left associative operator, then 1 @ 2 @ 3 is equivalent to (1 @ 2) @ 3. However, if C<@> is right associative, then 1 @ 2 @ 3 is equivalent to 1 @ (2 @ 3). There are other options for the associativity, but we'll discuss them as we come to them.
+In this C<INIT> block, we use the C<O> method of the compiler to set up two precedence levels: one
+for operators like addition (named C<%additive>), and one for operators like multiplication (named
+C<%multiplicative>). Each of themhas a ":prec" value and an ":assoc" value. ":prec" determines the
+precedence. Lexicographically greater values indicate higher precedence, so C<%additive> operators,
+with a precedence value of "t", have lower precedence than C<%multiplicative> operators with a
+precedence value of "u".":assoc" defines the associativity of the operators. If C<@> is a left
+associative operator, then 1 @ 2 @ 3 is equivalent to (1 @ 2) @ 3. However, if C<@> is right
+associative, then 1 @ 2 @ 3 is equivalent to 1 @ (2 @ 3). There are other options for the
+associativity, but we'll discuss them as we come to them.
token infix:sym<*> { <sym> <O('%multiplicative, :pirop<mul>')> }
This defines the operator C<*> (the C<infix:> is a prefix that tells the
operator parser that this operator is an infix operator; there are other types,
-such as prefix, postfix and others). As you can see, it uses the O rule to specify that it is part of the C<%multiplicative> group of operators. The ":pirop" value specifies that the operator should compile to the C<mul> PIR opcode.
+such as prefix, postfix and others). As you can see, it uses the O rule to specify that it is part
+of the C<%multiplicative> group of operators. The ":pirop" value specifies that the operator should
+compile to the C<mul> PIR opcode.
Of course, the expression parser does not just parse operators, it must also
parse the operands. So, how do we declare the most basic entity that represents
@@ -145,7 +156,9 @@
or even a function definition (but adding two function definition doesn't
really make sense, does it?). The operands are parsed in a recursive-descent
fashion, so somewhere the parser must switch back from bottom-up
-(expression parsing) to top-down. This "switch-back" point is the proto token C<term>. This is the reason why integer constants are parsed by the rule term:sym<integer_constant>, for example, in our grammar.
+(expression parsing) to top-down. This "switch-back" point is the proto token C<term>. This is the
+reason why integer constants are parsed by the rule term:sym<integer_constant>, for example, in our
+grammar.
The C<term> proto token is
invoked every time a new operand is needed
@@ -169,7 +182,8 @@
or
(".." is the string concatenation operator). Besides defining an entry and exit
-point for the expression parser, you need to define precedence levels for your operators. Find the C<INIT> block in Grammar.pm below the "## Operators" comment, and replace it with this:
+point for the expression parser, you need to define precedence levels for your operators. Find the
+C<INIT> block in Grammar.pm below the "## Operators" comment, and replace it with this:
INIT {
Squaak::Grammar.O(':prec<w>, :assoc<unary>', '%unary-negate');
@@ -226,7 +240,8 @@
In the previous section, we introduced the C<pasttype> clause that you can
specify. This means that for that operator (for instance, the C<and> operator
we discussed), a C<PAST::Op( :pasttype('if') )> node is created. What happens
-if you don't specify a pasttype? In that case, the corresponding action method is called. Obviously, some languages have very exotic semantics for the C<+> operator,
+if you don't specify a pasttype? In that case, the corresponding action method is called. Obviously,
+some languages have very exotic semantics for the C<+> operator,
but many languages just want to use Parrot's built-in C<add> instruction. How
do we achieve that?
@@ -250,23 +265,25 @@
=head2 To circumfix or not to circumfix
Squaak supports parenthesized expressions. Parentheses can be used to change
-the order of evaluation in an expression, just as you probably have seen in other languages. Besides infix, prefix and postfix operators, you can
-define circumfix operators, which is specified with the left and right
-delimiter. This is an ideal way to implement parenthesized expressions:
+the order of evaluation in an expression, just as you probably have seen in other languages. Besides
+infix, prefix and postfix operators, you can define circumfix operators, which is specified with the
+left and right delimiter. This is an ideal way to implement parenthesized expressions:
token circumfix:sym<( )> { '(' <.ws> <EXPR> ')' }
# with the action method:
method circumfix:sym<( )> { make $<EXPR>.ast; }
-This rule and action method were generated for us when we ran mk_language_shell.pl; you don't need to add them to the grammar and actions yourself.
-Circumfix operators are treated as terms by the operator-precedence parser, so it will parse as we want it to automatically.
+This rule and action method were generated for us when we ran mk_language_shell.pl; you don't need
+to add them to the grammar and actions yourself. Circumfix operators are treated as terms by the
+operator-precedence parser, so it will parse as we want it to automatically.
=head2 Expression parser's action method
For all grammar rules we introduced, we also introduced an action method that
is invoked after the grammar rule was done matching. What about the action
-method for EXPR? Our Squaak::Actions class inherits that from HLL::Actions. We don't have to write one.
+method for EXPR? Our Squaak::Actions class inherits that from HLL::Actions. We don't have to write
+one.
=head2 What's Next?
@@ -296,7 +313,12 @@
Hint: a floating-point constant should produce a value of type 'Float'.
-Note: in Perl 6 regexes, when matching an alternation as in a proto rule, the alternative which matches the most of the string is supposed to match. However, NQP-rx does not yet implement this. As a work-around, NQP-rx specifies that the version of a proto regex with the longest name will match. Since the part of a floating-point constant before the decimal place is the same as an integer constant, unless the token for floating-point constants has a longer name than the token for integer-constants, the latter will match and a syntax error will result.
+Note: in Perl 6 regexes, when matching an alternation as in a proto rule, the alternative which
+matches the most of the string is supposed to match. However, NQP-rx does not yet implement this. As
+a work-around, NQP-rx specifies that the version of a proto regex with the longest name will match.
+Since the part of a floating-point constant before the decimal place is the same as an integer
+constant, unless the token for floating-point constants has a longer name than the token for
+integer-constants, the latter will match and a syntax error will result.
=item *
@@ -323,7 +345,12 @@
Hint: a floating-point constant should produce a value of type 'Float'.
-Note: in Perl 6 regexes, when matching an alternation as in a proto rule, the alternative which matches the most of the string is supposed to match. However, NQP-rx does not yet implement this. As a work-around, NQP-rx specifies that the version of a proto regex with the longest name will match. Since the part of a floating-point constant before the decimal place is the same as an integer constant, unless the token for floating-point constants has a longer name than the token for integer-constants, the latter will match and a syntax error will result.
+Note: in Perl 6 regexes, when matching an alternation as in a proto rule, the alternative which
+matches the most of the string is supposed to match. However, NQP-rx does not yet implement this. As
+a work-around, NQP-rx specifies that the version of a proto regex with the longest name will match.
+Since the part of a floating-point constant before the decimal place is the same as an integer
+constant, unless the token for floating-point constants has a longer name than the token for
+integer-constants, the latter will match and a syntax error will result.
token term:sym<float_constant_long> { # longer to work around lack of LTM
[
Modified: trunk/examples/languages/squaak/setup.pir
==============================================================================
--- trunk/examples/languages/squaak/setup.pir Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/setup.pir Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,4 +1,5 @@
#!/usr/bin/env parrot
+# Copyright (C) 2010, Parrot Foundation.
# $Id$
=head1 NAME
Modified: trunk/examples/languages/squaak/squaak.pir
==============================================================================
--- trunk/examples/languages/squaak/squaak.pir Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/squaak.pir Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,4 @@
+# Copyright (C) 2010, Parrot Foundation.
# $Id$
=head1 TITLE
Modified: trunk/examples/languages/squaak/src/Squaak/Actions.pm
==============================================================================
--- trunk/examples/languages/squaak/src/Squaak/Actions.pm Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/src/Squaak/Actions.pm Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,5 @@
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
class Squaak::Actions is HLL::Actions;
method begin_TOP ($/) {
@@ -21,9 +23,10 @@
}
method stat_or_def($/) {
- if $<statement> {
+ if $<statement> {
make $<statement>.ast;
- } else { # Must be a def
+ }
+ else { # Must be a def
make $<sub_definition>.ast;
}
}
Modified: trunk/examples/languages/squaak/src/Squaak/Compiler.pm
==============================================================================
--- trunk/examples/languages/squaak/src/Squaak/Compiler.pm Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/src/Squaak/Compiler.pm Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,5 @@
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
class Squaak::Compiler is HLL::Compiler;
INIT {
Modified: trunk/examples/languages/squaak/src/Squaak/Grammar.pm
==============================================================================
--- trunk/examples/languages/squaak/src/Squaak/Grammar.pm Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/src/Squaak/Grammar.pm Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,5 @@
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
=begin overview
This is the grammar for Squaak in Perl 6 rules.
@@ -47,7 +49,7 @@
proto rule statement { <...> }
-rule statement:sym<assignment> {
+rule statement:sym<assignment> {
<primary> '=' <EXPR>
}
Modified: trunk/examples/languages/squaak/src/Squaak/Runtime.pm
==============================================================================
--- trunk/examples/languages/squaak/src/Squaak/Runtime.pm Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/src/Squaak/Runtime.pm Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,6 @@
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
# language-specific runtime functions go here
{
Modified: trunk/examples/languages/squaak/src/squaak.pir
==============================================================================
--- trunk/examples/languages/squaak/src/squaak.pir Tue Jul 20 08:40:01 2010 (r48122)
+++ trunk/examples/languages/squaak/src/squaak.pir Tue Jul 20 09:04:20 2010 (r48123)
@@ -1,3 +1,4 @@
+# Copyright (C) 2010, Parrot Foundation.
# $Id$
=head1 TITLE
More information about the parrot-commits
mailing list