Re: receivers of pipes (the sharp end again)

[Brad Bowman]

> I guess the real question is whether ==> my $x is really assigning a
> list or binding an iterator to a Lazy slot somewhere.  It feels like
> the latter is more useful.  Which means that ==> @x can return as soon
> as it binds the iterator to @x.specs.  It doesn't have to wait for all
> the values to be produced, which an assignment implies (kinda sorta).

Iterators/streams would also help lazy pipelines play well with GC.
Using an array seems to require shifts to reclaim memory, an
iterator would do the right thing by default.

Brad

-- 
 Intelligence is nothing more than discussing things with others.
 Limitless wisdom comes of this. -- Hagakure

Re: Building a module with tests

[Robert]

On 5/6/05 1:50 PM, in article
[EMAIL PROTECTED], "Steve Peters"
<[EMAIL PROTECTED]> wrote:

> On Fri, May 06, 2005 at 11:43:53AM -0400, Robert wrote:
>> "Andy Lester" <[EMAIL PROTECTED]> wrote in message
>> news:[EMAIL PROTECTED]
>>> On Thu, May 05, 2005 at 10:12:14AM -0400, Robert ([EMAIL PROTECTED])
>>> wrote:
 Is there an article on the current best practices about creating a module
 with tests? I know there is h2xs but I somewhere in the back of my foggy
 brain I am thinking I read somewhere of a different. more preffered
 method.
>>> 
>>> Go look at Module::Starter.  Also, buy a copy of Perl Testing
>>> Developer's Notebook as soon as it comes out.
>>> 
>>> xoxo,
>>> Andy
>>> 
>> 
>> :  )
>> 
>> Seems it is not available as a PPM for ActiveStates Perl distro.
>> 
> 
> Looking at http://ppm.activestate.com/BuildStatus/5.8-M.html, the
> Module-Starter distribution is available for the ActiveState 5.8.x Perls.
> 
> Steve Peters
> [EMAIL PROTECTED]

It doesn't show up though. I will look again on Monday and if it isn't there
I will do a manual install.

Robert

Re: [svn:parrot] rev 8004 - trunk/build_tools

[Leopold Toetsch]

[EMAIL PROTECTED] <[EMAIL PROTECTED]> wrote:

> Modified:
>trunk/build_tools/build_nativecall.pl
> Log:

> Added a seen hash so that we don't get redefinition errors when things
> are listed twice (as they probably ought to be if they're for specific
> libraries).


> +next if $seen{"$ret$;$args"}++;

This gives ugly warnings, if the call signature has no $args. But, we
have e.g.

  i   # void call, int ret
  i  v# same - explicit void call

These create of course the same code twice with different names. I tried
to remove signatures of the first type, but then Parrot PANICs during
startup.

What we really should do is:
- have just one of these equivalent signatures
- warn if there is a duplicate and ignore it

Patch reverted for now.

leo

Re: [PATCH] make testr

[Leopold Toetsch]

Dino Morelli <[EMAIL PROTECTED]> wrote:
> On Sat, 7 May 2005, Dino Morelli wrote:

>>On Sat, 7 May 2005, Leopold Toetsch wrote:

>$ ./parrot -o foo.pbc foo.imc
>$ ./parrot foo.pbc

>>The part I'm unsure of is the exit codes.
>>I could change it to watch for a bad code during the for loop with the
>>system(), bail out right there and send that code back.

> I thought about it and realized that this is wrong. All of the commands
> that used to be one line need to be run or the test case won't see the
> output it's looking for. Which in some cases is an intentional failure
> with nonzero return value.

Yep.

> So, forget I said anything about the exit codes. The real patch:

Thanks, applied.
leo

parrotcode.org needs some updating

[Leopold Toetsch]

http://www.parrotcode.org/resources.html still has CVS and CVS 
instructions mentioned. Please replace it with equivalent SVN hints.

Thanks,
leo

Re: parrotcode.org needs some updating

[Leopold Toetsch]

Leopold Toetsch wrote:
http://www.parrotcode.org/resources.html still has CVS and CVS 
instructions mentioned. Please replace it with equivalent SVN hints.
... which are at http://www.parrotcode.org/source.html
Thanks,
leo

starting release

[Leopold Toetsch]

Please no more svn commits.
Thanks,
leo

Re: Overriding/redefining p6 built-in functions

[Larry Wall]

On Sun, May 08, 2005 at 02:39:03PM +1000, Andrew Savige wrote:
: A crude hack sometimes used by gung ho p5 testers is to redefine
: perl built-in functions. For example:
: 
: BEGIN {
: *CORE::GLOBAL::read = sub (*\$$;$) { return undef };
: }
: 
: to test read failures (and so boost your Devel::Cover score :-).
: This technique is not very convenient (must be in a BEGIN block).
: Moreover, some p5 functions (e.g. print) cannot be overridden.

It's not clear that Perl 6 has *any* built-in functions in the sense
that Perl 5 does.  All global functions live in the * namespace, which
is the last place Perl looks.  Any lexical or package scope will
override a * function.

You can also do partial overrides of multimethods when you have enough
type information.

You also have control of the Perl grammar so that, even if something
is more "built-in" than a global function, you can change the grammar
rule that parses it.  On a small scale, this means you can define macros
in various grammatical categories.

: I was wondering how/if p6 will support the overriding of built-in
: functions (I imagine QA would be the main use for this).

Absolutely everything is overridable in Perl 6, except the fact that
the program is parsed as Standard Perl up till the first declaration
(which might, of course, occur before the program file in a switch.)

Larry

Re: Overriding/redefining p6 built-in functions

[Gaal Yahas]

On Sun, May 08, 2005 at 07:20:04AM -0700, Larry Wall wrote:
> Absolutely everything is overridable in Perl 6, except the fact that
> the program is parsed as Standard Perl up till the first declaration
> (which might, of course, occur before the program file in a switch.)

On that note, http://perlnomic.org/ .

-- 
Gaal Yahas <[EMAIL PROTECTED]>
http://gaal.livejournal.com/

PGE features update

[Patrick R. Michaud]

There have been a lot of substantial updates to the Parrot Grammar
Engine, so I figure it's a good time for a summary report.  The latest 
version (in the Parrot cvs trunk) now incorporates:

 -  subrules
 -  capture aliases (named and numbered)
 -  the :w modifier and  subrules
 -  word boundaries (\b and \B)
 -  simple backreferences  ($1, $2, $, etc.)

Also, more tests have been added to t/p6rules, but we definitely
need more.  Tests are especially needed for:
 -  Rules specified with and without :w modifiers
 -  calls to subrules
 -  named alias captures
 -  numbered alias captures
 -  \s \S \w \W \d \D \n \N

S05 is currently being updated to include information about how
captures work in Perl 6 (and PGE).  But for those who are eager
to get started, I've summarized the essentials as PGE implements
them below.

Questions, comments, patches, and tests welcomed.

Pm

==

* Rules are Parrot subroutines that know how to match strings.  To
  compile a rule, one uses the "PGE::p6rule" function:

.sub main
.local pmc p6rule
.local pmc rulesub
.local pmc match
load_bytecode "PGE.pbc"
p6rule = find_global "PGE", "p6rule"

rulesub = p6rule(":w (\w+) \:= (\S+)")
match = rulesub("dog := spot")
 
* A rule subroutine returns a "match object" containing the
  results of the match.  In Perl 6, this object will be known as C< $/ >.

* A match object returned from a successful match has the following
  characteristics:
  - true in boolean context
  - 1 in a numeric context (may change later with :g modifier)
  - the string matched in string context
  - .from() and .to() are offsets delimiting the string where 
the match was found
  - contains other match objects resulting from captured
subpatterns or subrules in the match

* A rule containing capturing parens gets additional match objects
  for each set of parens.  Thus a rule like:

 $1$2
rulesub = p6rule(":w(\w+) \:= (\S+)")

  captures the word characters prior to the ":=" into $/[0], and 
  the non-space characters following the ":=" into $/[1].  (In Perl 6,
  the $1, $2, ... variables will be aliases to $/[0], $/[1], ... . )

rulesub = p6rule(":w(\w+) \:= (\S+)")
match = rulesub(" let foo := 123 ")
print match# outputs "foo := 123"
$P0 = match[0] # first subpattern capture ($1)
print $P0  # outputs "foo"
$P0 = match[1] # second subpattern capture ($2)
print $P0  # outputs "123"

* If a capture is quantified with any of '+', '*', or '**{m..n}',
  then it generates an array of match objects for the subpattern capture
  instead of a single match object:

rulesub = p6rule(":w(\w+) \:= (\S+ )*")
match = rulesub(" foo := zip boom bah")
print match# outputs "foo := zip boom bah"
$P0 = match[0] # first subpattern capture ($1)
print $P0  # outputs "foo"
$P1 = match[1] # second subpattern array ($2)
$P2 = $P1[0]   # second repetition ($2[0])
print $P2  # outputs "zip "
$P2 = $P1[1]   # second repetition ($2[1])
print $P2  # outputs "boom "

* Match objects for nested captures are nested into the surrounding
  capture object.  Thus, given

rulesub = p6rule(":w (let) ( (\w+) \:= (\S+) )")
match = rulesub("let foo := 123")

  the outer match object contains two match objects ($/[0] and $/[1]),
  and the second of these contains two match objects at
  $/[1][0] and $/[1][1].

print match# outputs "let foo := 123"
$P0 = match[0] # first subcapture ($1)
print $P0  # outputs "let"
$P0 = match[1] # second subcapture ($2)
$P1 = $P0[0]   # first nested capture ($2[0])
print $P1  # outputs "foo"
$P1 = $P0[1]   # second nested capture ($2[1])
print $P2  # outputs "123"

* Non-capturing subpatterns don't nest match objects:

rulesub = p6rule(":w (let) [ (\w+) \:= (\S+) ]")
match = rulesub("let foo := 123")
print match# outputs "let foo := 123"
$P0 = match[0] # first subcapture ($1)
print $P0  # outputs "let"
$P0 = match[1] # second subcapture ($2)
print $P0  # outputs "foo"
$P0 = match[2] # third subcapture ($3)
print $P0  # outputs "123"

* To define a subrule, store its subrout

release done

[Leopold Toetsch]

I hope all is working and may the checkins continue,
leo

Parrot 0.2.0 "NLnet" Released!

[Leopold Toetsch]

Parrot 0.2.0 "NLnet" Released!
On behalf of the Parrot team I'm proud to announce the release of
Parrot 0.2.0 and I'd like to thank all involved pepole as well as
our sponsors for supporting us.
It's a pleasure and honor for me to be able to advertise (after 0.1.0) the
next leap release 0.2.0 with almost complete MMD support.
What is Parrot?
Parrot is a virtual machine aimed at running Perl6 and other dynamic
languages.
Parrot 0.2.0 changes and news
* parrot repository is now under subversion
* MMD (Multi Method Dispatch) refactored
* new unary and infix opcodes that return new result PMCs
* dynamic scalar PMCs inherit now almost all from Parrot core PMCs
* more unification of PMCs and ParrotObjects
* tailcalls for functions and methods
* PGE (Parrot Grammar Engine) reworked
* Pugs creates Parrot code and Pugs is a registered Parrot compiler
* new languages/lisp
* the usual bug fixes and improvements
After some pause you can grab it from
.
As parrot is still in steady development we recommend that you
just get the latest and best from SVN by following the directions at

Turn your web browser towards  for more
information about Parrot, get involved, and:
Have fun!
leo

PGE features update (corrections)

[Patrick R. Michaud]

[Correcting typographic errors noticed after sending original.  Sorry
for the errors and duplicate posts.  Also, in many of the double
quoted strings below the backslashes should probably be escaped
(i.e., "\\s" instead of "\s") but I'm leaving them alone for 
readability.  --Pm]

* Rules are Parrot subroutines that know how to match strings.  To
  compile a rule, one uses the "PGE::p6rule" function:

.sub main
.local pmc p6rule
.local pmc rulesub
.local pmc match
load_bytecode "PGE.pbc"
p6rule = find_global "PGE", "p6rule"

rulesub = p6rule(":w (\w+) \:= (\S+)")
match = rulesub("dog := spot")
 
* A rule subroutine returns a "match object" containing the
  results of the match.  In Perl 6, this object will be known as C< $/ >.

* A match object returned from a successful match has the following
  characteristics:
  - true in boolean context
  - 1 in a numeric context (may change later with :g modifier)
  - the string matched in string context
  - .from() and .to() are offsets delimiting the string where 
the match was found
  - contains other match objects resulting from captured
subpatterns or subrules in the match

* A rule containing capturing parens gets additional match objects
  for each set of parens.  Thus a rule like:

 $1$2
rulesub = p6rule(":w(\w+) \:= (\S+)")

  captures the word characters prior to the ":=" into $/[0], and 
  the non-space characters following the ":=" into $/[1].  (In Perl 6,
  the $1, $2, ... variables will be aliases to $/[0], $/[1], ... . )

rulesub = p6rule(":w(\w+) \:= (\S+)")
match = rulesub(" let foo := 123 ")
print match# outputs "foo := 123"
$P0 = match[0] # first subpattern capture ($1)
print $P0  # outputs "foo"
$P0 = match[1] # second subpattern capture ($2)
print $P0  # outputs "123"

* If a capture is quantified with any of '+', '*', or '**{m..n}',
  then it generates an array of match objects for the subpattern capture
  instead of a single match object:

rulesub = p6rule(":w(\w+) \:= (\S+ )*")
match = rulesub(" foo := zip boom bah")
print match# outputs "foo := zip boom bah"
$P0 = match[0] # first subpattern capture ($1)
print $P0  # outputs "foo"
$P1 = match[1] # second subpattern array ($2)
$P2 = $P1[0]   # second repetition ($2[0])
print $P2  # outputs "zip "
$P2 = $P1[1]   # second repetition ($2[1])
print $P2  # outputs "boom "

* Match objects for nested captures are nested into the surrounding
  capture object.  Thus, given

rulesub = p6rule(":w (let) ( (\w+) \:= (\S+) )")
match = rulesub("let foo := 123")

  the outer match object contains two match objects ($/[0] and $/[1]),
  and the second of these contains two match objects at
  $/[1][0] and $/[1][1].

print match# outputs "let foo := 123"
$P0 = match[0] # first subcapture ($1)
print $P0  # outputs "let"
$P0 = match[1] # second subcapture ($2)
$P1 = $P0[0]   # first nested capture ($2[0])
print $P1  # outputs "foo"
$P1 = $P0[1]   # second nested capture ($2[1])
print $P1  # outputs "123"

* Non-capturing subpatterns don't nest match objects:

rulesub = p6rule(":w (let) [ (\w+) \:= (\S+) ]")
match = rulesub("let foo := 123")
print match# outputs "let foo := 123"
$P0 = match[0] # first subcapture ($1)
print $P0  # outputs "let"
$P0 = match[1] # second subcapture ($2)
print $P0  # outputs "foo"
$P0 = match[2] # third subcapture ($3)
print $P0  # outputs "123"

* To define a subrule, store its subroutine into a symbol table somewhere:

rulesub = p6rule("int | double | float | char")
store_global "type", rulesub 
rulesub = p6rule("\w+")
store_global "ident", rulesub

* To match a subrule, put the name of the subrule in angle brackets:

rulesub = p6rule(":w ")
match = rulesub("   int argc ")
print match# outputs "int argc"

* Subrule captures become named keys in the resulting match object:

rulesub = p6rule(":w ")
match = rulesub("   int argc ")
print match# outputs "int argc"

Re: possible change to is_digit, is_wordchar, etc

[Jens Rieks]

Hi,

C is now implemented. The second part (find_(not_)cclass) will 
follow tomorrow.

jens

PS: The "get_byte past the end of the buffer (1 of 1)" error is hopefully 
fixed, too. Don't know if it is the cleanest way, but it at least works :-)

Re: [perl #34917] test t/op/trans.t#13 failed on OpenBSD 3.5/i386

[Jens Rieks]

On Tuesday 12 April 2005, Steve Peters via RT wrote:
> This ticket is a duplicate of ticket #34549. ÂI'll have a patch for this
> issue later this week.
It is not fixed yet, can you please give a status update?
Are you still working on it?

jens

[PATCH] "Name not found" vs. "No applicable method"

[Bob Rogers]

   The following patch makes Parrot_get_name report a different error
message if Parrot_MMD_search_default_func finds nothing, to distinguish
this from the case where nothing is found.  I am finding this helpful in
debugging.

   But this seems like a band-aid, for two reasons:

   1.  find_name can never return a MultiSub, and find_global doesn't
seem to work.  So I can't get a handle on a MultiSub built for me by
IMCC.

   2.  Even if I had it, I couldn't call it, because the dispatch is
done by find_name.

   Seems to me (IMHO) that the MultiSub invoke method is the right place
to do the actual dispatching, but I don't understand all the magic
involved.  Also, this would seem to interact with changes to the calling
conventions [1], so perhaps this patch is premature.

   Is there a MultiSub API, or one in the works?

-- Bob Rogers
   http://rgrjr.dyndns.org/

[1]  Leo, "[PROPOSAL] call syntax abstraction", Tue, 03 May 2005
 13:58:14 +0200.


Index: src/global.c
===
--- src/global.c(revision 8008)
+++ src/global.c(working copy)
@@ -195,6 +195,7 @@
 Parrot_get_name(Interp* interpreter, STRING *name)
 {
 PMC *g, *pad, *current_sub, *name_space;
+int multi_sub_p = 0;
 
 pad = scratchpad_get_current(interpreter);
 g = scratchpad_find(interpreter, pad, name);
@@ -215,6 +216,7 @@
  * signature is currently passed in S1
  * see also imcc/pcc.c
  */
+multi_sub_p = 1;
 g = Parrot_MMD_search_default_func(interpreter, name, REG_STR(1));
 if (g)
 return g;
@@ -222,12 +224,18 @@
 else
 return g;
 }
-if (PARROT_ERRORS_test(interpreter, PARROT_ERRORS_GLOBALS_FLAG))  {
+if (! PARROT_ERRORS_test(interpreter, PARROT_ERRORS_GLOBALS_FLAG))  {
+return pmc_new(interpreter, enum_class_Undef);
+}
+else if (multi_sub_p) {
+/* we found the name, it's just that we couldn't dispatch. */
 real_exception(interpreter, NULL, E_NameError,
-"Name '%Ss' not found", name);
+   "No applicable '%Ss' method found", name);
 }
-
-return pmc_new(interpreter, enum_class_Undef);
+else {
+real_exception(interpreter, NULL, E_NameError,
+   "Name '%Ss' not found", name);
+}
 }
 
 /*
Index: t/pmc/mmd.t
===
--- t/pmc/mmd.t (revision 8008)
+++ t/pmc/mmd.t (working copy)
@@ -476,7 +476,7 @@
 PerlSt ok 2
 PerlSt ok 3
 String ok 4
-Name 'p' not found/
+No applicable 'p' method found/
 OUT
 
 pir_output_is(<<'CODE', <<'OUT', "MMD on PMC types 3");

[PATCH] PGE::Hs for Pugs PGE support

[Autrijus Tang]

Greetings.  Attached is a patch that I'm currently using in Pugs's
bundled PGE.pbc, in order to make PGE output properly escaped strings,
in a format ready to be used form Haskell FFI.

I'd appreciate comments, and if it's okay to commit it back to the
PGE directory.

Thanks,
/Autrijus/
 Patch <-> level 1
Source: [No source]
Target: d31e2699-5ff4-0310-a27c-f18f2fbe73fe:/trunk/compilers/pge:8010
(http://svn.perl.org/parrot/trunk)
Log:
* Haskell-compatible dump of matches
=== PGE/Hs.pir
==
--- PGE/Hs.pir  (revision 8010)
+++ PGE/Hs.pir  (patch - level 1)
@@ -0,0 +1,130 @@
+=head1 Title
+
+PGE::Hs - Match and display PGE rules as Haskell expressions
+
+=head1 SYNOPSIS
+
+.sub _main
+load_bytecode "PGE.pbc"
+$P0 = find_global "PGE::Hs", "match"
+$S0 = $P0("Hello\n", "H(.)llo(.)")
+print $S0   # Just [(0, "Hello\n"), (1, "e"), (5, "\n")]
+.end
+
+=cut
+
+.namespace [ "PGE::Hs" ]
+
+.sub __onload 
+load_bytecode "library/Data/Escape.imc"
+.end
+
+.sub "match" method
+.param string x
+.param string pattern
+.local pmc rulesub
+.local pmc match
+.local pmc p6rule_compile
+.local string out
+
+find_global p6rule_compile, "PGE", "p6rule"
+null rulesub
+
+rulesub = p6rule_compile(pattern)
+match = rulesub(x)
+  match_result:
+unless match goto match_fail
+out = "Just ["
+$S0 = match."dump_hs"()
+concat out, $S0
+concat out, "]\n"
+goto end_match
+  match_fail:
+out = "Nothing\n"
+goto end_match
+  end_match:
+.return (out)
+.end
+
+.namespace [ "PGE::Match" ]
+
+.sub "dump_hs" method
+.local pmc capt
+.local int spi, spc
+.local pmc iter
+.local string escaped
+.local pmc escape
+.local string out
+
+out = ""
+
+unless argcS < 3 goto start
+unless argcS < 2 goto start
+  start:
+escape = find_global "Data::Escape";, "String"
+$I0 = self
+unless $I0 goto subpats
+$S0 = self
+escaped = escape($S0)
+$I0 = self."from"()
+$S0 = $I0
+concat out, "("
+concat out, $S0
+concat out, ", \""
+concat out, escaped
+concat out, "\")"
+
+  subpats:
+$I0 = self
+capt = getattribute self, "PGE::Match\x0@:capt"
+isnull capt, subrules
+spi = 0
+spc = elements capt
+  subpats_1:
+unless spi < spc goto subrules
+$S0 = spi
+$I0 = defined capt[spi]
+unless $I0 goto subpats_2
+$P0 = capt[spi]
+bsr dumper
+  subpats_2:
+inc spi
+goto subpats_1
+
+  subrules:
+capt = getattribute self, "PGE::Match\x0%:capt"
+isnull capt, end
+iter = new Iterator, capt
+iter = 0
+  subrules_1:
+unless iter goto end
+$S0 = shift iter
+$I0 = defined capt[$S0]
+unless $I0 goto subrules_1
+$P0 = capt[$S0]
+bsr dumper
+goto subrules_1
+
+  dumper:
+$I0 = 0
+$I1 = elements $P0
+unless $I0 < $I1 goto dumper_1
+$P1 = getprop "isarray", $P0
+if $P1 goto dumper_2
+$P1 = $P0[-1]
+concat out, ", "
+$S0 = $P1."dump_hs"()
+concat out, $S0
+  dumper_1:
+ret
+  dumper_2:
+unless $I0 < $I1 goto dumper_1
+$P1 = $P0[$I0]
+concat out, ", "
+$S0 = $P1."dump_hs"()
+concat out, $S0
+inc $I0
+goto dumper_2
+  end:
+.return (out)
+.end
=== PGE.pir
==
--- PGE.pir  (revision 8010)
+++ PGE.pir  (patch - level 1)
@@ -25,9 +25,12 @@
 load()
 load = find_global "PGE::P6Rule", "__onload"
 load()
+load = find_global "PGE::Hs", "__onload"
+load()
 .end
 
 .include "PGE/TokenHash.pir"
 .include "PGE/Exp.pir"
 .include "PGE/Match.pir"
 .include "PGE/P6Rule.pir"
+.include "PGE/Hs.pir"

 BEGIN SVK PATCH BLOCK 
Version: svk 0.994 (freebsd)

eJx9Vftv29YVdlAs3YSkgIetS+e1uFAYwM4kmQ+ZlrXYUzo+JFm25Spp4kaGekle2pwpkuAjtQtt
HR+iHrZsqxvQ7af9qzuUE2wFthkGdS/P+b7vnMtzz5HcF7+rMYOdHXpAMfSg8+VutdrGvnr6BHYU
PyCa4dsutTEwyVtiUtzAtE+o8sDCfQJWH7snxN/ZYQBcuQOLC8B7knLGoWDftjxqa0HW811CKGZQ
rm0MauygxgF0wIDRdojVc23bBzGG5yscWHtZTKppe6SXYcEZUODPUkz5DqAZLlFB8AJCa8vigus9
fuFafk+tGyahNjOnkmO4P3LkMqGNd0L/ZgSXLEI+o+GoygBr2h0LBAU063XvHRPbo9hBkfnfPGzG
s3FnxY5jXvR8cu5rxPRxxg3vOW4Lzm9/aWnpbw+HXyUv/9KSl/4udgX7h8bZXAzvCctD4ZPdMBcK
4cdXQli6apwNxbAGyxdyuDcRoweJEOVCqftDM3ySSDgW/FDsHvj/kKI1EcshM5K61534cSr9cSoV
o3Z8KIYsPCOhNG7Fh3K8HgoRI9it8Nf7ycMwUwxLUvJQCnNJI/5aTFg5xtFB8nkox00pVAAd1ZPz
SFgsx2BP5eFniTzkEliPpPBbQErhczBegnsqDPVQGF4cpssJGMRhJ6nH583ha2lYk4cno6O00khF
2Mzq8c++iHjxUTNqNtL7e/FvmvGrpDU6FkJr3B4dJ51kJRSj7w5HXWlMd5MVQIdS4slDaSKlv0+k
kXMw/ibcn3woTh4CHzi1w18J0UUkRX+GlEIxpuWhnx1j0pr8XJi40uSn6e4waEzO5TEdydPfQoBK
c+Km9fQjOXwedlIqhJBx+nHyxfTb1pjeS5/G4tiRp8vAfzBxhVH/RpzmpeRQHj0bwg68IzE5gVUo
XL4SS9nhSCkVC1NuVB+ZAIz2hjXh6vNQvNqrTx80ryry9NNo9/LrkXhVSqTo8avpvUiaLYvhL/dn
bCKkH4rjlcasDXpxY7ayN9sN5csXYgn2p5d++PrqUyF6Kl7n/toE9psPhJSqXxcOrs7Emw/qaa01
W06a40edGRUfzaryzXp7dtS4+dPezG1eP6rffhLJs6B12csibF0dRvC7O70XircufCVp9rZx+

Re: parrotcode.org needs some updating

[Robert Spier]

> Leopold Toetsch wrote:
> > http://www.parrotcode.org/resources.html still has CVS and CVS
> > instructions mentioned. Please replace it with equivalent SVN hints.
> 
> ... which are at http://www.parrotcode.org/source.html

Updated.

As always, patches for this kind of thing are welcome.  

(You can patch against
https://svn.perl.org/perl.org/docs/live/parrotcode/)

-R