-In Functions
Expressions and Statements
Operators
Unary
Binary
Hyper-Operators
Built-In Functions
Pattern Matching
Modules and Classes
Modules
Classes
Grammars
Standard Library
Pragmas
d wondering, "what about the
glossary?" Well, cross-referencing glossary entries is just this in
Perl 6:
$text =~ s:each / (%glossary_entries) /$1/;
Where %glossary_entries's values are a unique entry ID of some sort.
And if that's not easy enough for you, you can always
ou're numbering or each bullet handles multiple paragraphs,
there's no reason you need to state the =over/=back explicitly, IMHO.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. Yo
$str="0";
ok(?$str, "0 is false");
$str="";
ok(?$str, "Empty string is false");
This way, you can still echo the structure of the documentation, but the
tests don't clutter up the docs.
--Brent Dax
Garrett Goebel:
# =*> level1
# =>> level2
# =+>>> level3
# =*>>>> level4
# =>>> level3
# => level1
Too much punctuation, IMHO. If it ever does become necessary to do
multi-level bulleting and stuff, we might as well m
Garrett Goebel:
# Brent Dax wrote:
# >
# > Garrett Goebel:
# > # =*> level1
# > # =>> level2
# > # =+>>> level3
# > # =*>>>> level4
# > # =>>> level3
# > # => level1
# >
# > Too much pun
Michael Lazzaro:
# On Tuesday, November 12, 2002, at 10:01 AM, Brent Dax wrote:
# > Why use POD like this instead of a more atomic version of
# the standard
# > testing format used by Perl 5? We can use the directory
#
# Dunno, looking for a way where we can harness the autho
Dave Whipp:
# Maybe there's a terminology problem: but what is a regression
# test? In my world, we create a regression by running existing
My understanding is that a "regression test" is basically a test to make
sure a bug doesn't come back once it's been fixed.
--Br
Michael Lazzaro:
# What should be the syntax for closing a section?
How about the empty string? Isn't the end of a section defined by EOF
or when the next section starts?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegrap
Michael Lazzaro:
# On Tuesday, November 12, 2002, at 04:08 PM, Brent Dax wrote:
# > Michael Lazzaro:
# > # What should be the syntax for closing a section?
# >
# > How about the empty string? Isn't the end of a section
# defined by EOF
# > or when the next section starts
ave the self-modifying parser Larry
desperately wants. But don't worry--we'll ship it already bytecompiled.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New Yo
any). This is much
scarier than it sounds--it's a lot like the !(x || y) == (!x && !y)
rule.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and h
Of course, the can of worms that
opens is horrifying to consider (and no longer has the benefit of the
ugly caller.MY). :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his ta
de it in the Perl language or write it specially
for Exporter. If we write it specially for Exporter, someone will
generalize the code and put it in a module (witness PadWalker.pm), so we
might as well have it in the base language and save someone some
hassles.
--Brent Dax <[EMAIL PROTECTED]>
how does Exporter declare its import() function?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and his head is meowing in Los Angeles. And radio operates
exact
Piers Cawley:
# So, how would one create a class which inherits from some
# other class when you don't know what said other class is
# until runtime?
AUTOLOAD! *ducks*
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"I
ng to be the basic XS mechanism, why don't we just ask the
user (or, more likely, the preprocessor) to write an argument-handling
routine?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously
Martin D Kealey:
# On Wed, 2002-11-20 at 15:01, Brent Dax wrote:
# > We need that capability if we're going to have lexically-scoped
# > exports:
#
# Whilst it would be useful for pragmatic modules to access
# anything and everything in the current compilation scope, I
# submit tha
o
the Wrong Thing. (Of course, the C (or whatever) class would
probably do this conversion implicitly for, say, passing into a
subroutine.)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evi
ainfuck already has an established name. We should use it, even if a
couple people won't understand that it wasn't our idea to call it that.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageo
ements in the middle of a loop--something Perl
doesn't like. :^( (Not that I don't understand *why* Perl doesn't
allow it--just that it can be an inconvenience.)
# you rarely handle strings character by character which can
# severely confuse C programmers.
Well, that's a sill
quot; ~ $self.CLASS() ~ "']";
# }
Once again, what's wrong with:
method str() {
#Unnamed invocant means you need $_, right?
return $_.class() ~ "($_.id())";
}
(where id() returns a uniquely identifying integer, usually the
address).
--B
s apporpriate for an object to stringify with its id.
To tell you the truth, I don't consider arrayrefs references anymore.
They're just Array objects that don't happen to be in @whatever symbols.
I don't know if this is the official view, but that fits my brain
better.
--Brent Dax &
Joseph F. Ryan:
# Brent Dax wrote
#
# >To tell you the truth, I don't consider arrayrefs references
# anymore.
# >They're just Array objects that don't happen to be in @whatever
# >symbols. I don't know if this is the official view, but that fits my
# >brain b
Damian Conway:
# > Also, can I return superpositions (sorry, junctions), to provide
# > multiple classifications? Or would I return an array for that?
#
# A (dis)junction ought to work there.
That sounds horribly scary...
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot
ted or even expressed as an
exercise for the reader. :^) )
[ It seems that this thread has drifted off-topic. Perhaps a renaming
is in order? ]
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously
value.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
--Ayn Rand, explaining how today's philosophies came to be
anguage to implement, we would
have stuck with something that looks and feels like C. Perl is designed
to make the *programmer*'s life easier, not the implementer's.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want
th .str and .id. If you're worried about namespace pollution,
maybe prefix:~ and prefix:id can be used instead.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must
could
# be an object of any class that inherits from Foo. So there's
# no way of knowing which class's C method to invoke.
Your point being...? Shouldn't it only dispatch to methods defined in
Foo? If it's typed as Foo, you shouldn't be using any methods that
aren't
ic is going on. I see nothing wrong
with this rule.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
e associated with a certain
signature?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
--Ayn Rand, explaining how today's philosophies came to be
) {
return .id();
}
method id() {
return sprintf("%s(%#x)", .class,
Perl6::addressof($_));
#Or some such nonsense
}
}
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"P
use to do things like UNIVERSAL::isa() in Perl.)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
--Ayn Rand, explaining how today's philosophies came to be
main.*can('foo')
# :
# : result in?
#
# These days it's "Main", not "main". And it's a module, not a
# class, so probably it fails, unless someone can think of
# something useful for it to mean.
I'd hope that Perl would allow me to do something li
from backing-store).
Under all systems I can think of, the memory address of an object's
header is constant. The data may move, but the header stays constant.
This is to minimize the insanity of pointer chasing in C.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"}
#x27;t think I want to
know. Might make my head explode or something. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
--Ayn Rand, explaining how today's philosophies came to be
blem. (Don't know how that would work with the whole immutable hash
keys thing, though...)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly c
Dan Sugalski:
# Wow, really spiffy. Can we get all the back-end infrastructure
# watching stuff (this, bonsai, tinderbox, RT) linked together
# somewhere central?
http://www.parrotcode.org/resources
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen
o the printing.
The fix is now in CVS. The tests were passing in (64-bit) INTVALs, but
were told to expect (32-bit) ints:
INTVAL ival;
...
ival=...;
Parrot_sprintf(..., "== %#x", ival);
/*^^^ needs to be %#vx (v for VAL)
where an C is printed with "%d" format.
Because those ones were the only ones I noticed were broken. :^)
Implied patch applied.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evi
sort map grep @a: {grepblock} {mapblock};
#I'm not sure you can actually leave out the
# parens--it might be ambiguous.
I assume you can see why this is a Bad Thing.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configur
Michael Lazzaro:
# On Thursday, December 19, 2002, at 08:35 AM, Brent Dax wrote:
# > Eww. Indir object is like this:
# >
# > @out = sort map grep @a: {grepblock} {mapblock};
# > #I'm not sure you can actually leave out the
# > # parens--it might be ambiguous.
#
re checking, I think that compiler is
# Microsoft's. If Brent Dax will verify that his original
# intent was for those pragmas to apply only to Microsoft's C
# compiler, then an improvement would be to change one line of
I didn't introduce these. Looking at the CVS logs, I find
anchor_stack_top;
...
stack_push(interpreter, interpreter->jb_stack, jb);
}
}
Yeah, I know, macros are evil, but they make this code *s* much
prettier...
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Co
of', and A is
always after an 'is'. (If you think of a variable as a stack of
properties, this 'is' is just specifying the root property.)
Is that clear enough, or should I say it a little slower?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_&quo
~| grep $_%2==0 ~> @evennumbers;
Congratulations on re-inventing C. :^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unin
method infix:~> (Code $sub);
method infix:~> ($target);
Or somesuch.
# I agree that they look nice. It's a shame that they're being
# used for such an awful proposal.
He was saying that they look nice for this application, so you obviously
don't agree.
--Brent Dax &l
Steve Fink:
# -memcpy(targ, ret->strstart, ret->bufused);
# -targ[ret->bufused + 1] = '\0';
# +memcpy(targ, ret->strstart, ret->strlen);
# +targ[ret->strlen] = '\0';
I could be wrong, but isn't strlen the length in characters ra
ve whatever the most popular encoding is in
their country. The "default default string type" will be utf8, but it's
currently ASCII because Unicode Is Hard.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to p
ally Bad Things.
Would you rather that Parrot implement Unicode once and make sure it's
right, or that a dozen languages all implement their own incompatible,
broken Unicode systems?
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
&qu
tten death.
#
# How about people who can't? Lots of people don't own the
# computer they're using, so to upgrade stuff they'd have to
# ask the sysadmin. And you know what happens when you annoy
# the sysadmin...
I suspect that was sarcasm.
--Brent Dax <[EMAIL PROTEC
nd they
don't unless they're trying to be perverse.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligible."
--Ayn Rand, explaining how today's philosophies came to be
Simon Cozens:
# [EMAIL PROTECTED] (Brent Dax) writes:
# > # could do the same thing with a sub with a prototype of
# > # (&block, *@list).
# >
# > Great. That could mean it won't work right for
# > MyCustomArrayLikeThing.
#
# Can you explain what you mean by this, beca
or (3).
#
# Of course, since indirect-object syntax is syntactic sugar
# itself, this
# goes on to be:
#
## function :@a ===> @a.function, applied repeatedly
#@out = @in.map({...}).grep({...});
#
# which is yet another L2R syntax.
Correct.
# But it also implies that map(&bl
Damian Conway:
# > Brent Dax wrote:
# >> Incorrect.
# No. Your reading was correct. This is a rare case of Brent
# being mistaken.
Ack, sorry to both you and Buddha, and anyone else I inadvertently
confused. Well, at least I'm good enough for this to be considered a
"rare&q
+ operator overloading for e.g. "operator +(int,
MyStringType)"...)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
"If you want to propagate an outrageously evil idea, your conclusion
must be brazenly clear, but your proof unintelligib
would be able to take a single subroutine call instead of a block:
if $cond {
...
}
else if $cond2 {
...
}
Yes, I know this means that we have 'else if' instead of 'elsif', but
it's only two more characters and it makes t
eparable keywords are in general a bad design, so perhaps they
should be grammar-munge hard. We really don't need anything but else
(and possibly its friends) for our purposes, but we want them
everywhere, so I don't see why we shouldn't do it this way.
--Brent Dax <[EMAIL PROTECT
y requires that each step in the process be
# overridable. (1. look up attribute 2. call attribute, at least in
# `callmethod's case).
I'm not sure exactly how this would be implemented but...um...I'm sure
you *could* do it. ;^)
Dan: with the various AUTOLOAD-esque features,
reasing numbers. (The first means that any metadata we
decide to add in the future will be slower than the metadata we add now;
the second has problems with several third-party tools picking the same
number.)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding
Dan Sugalski:
# At 12:10 AM -0800 1/23/03, Brent Dax wrote:
# >Dan Sugalski:
# ># Since it looks like it's time to extend the packfile
# format and the #
# >in-memory bytecode layout, this would be the time to start
# discussing #
# >metadata. What sorts of metadata do people
o(1..10 : 2) #Presumably wrong
foo((1..10) : 2)#Presumably right
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God' to "prove" it is who it says it is?
"
Michael Lazzaro:
# On Thursday, January 23, 2003, at 02:24 PM, Brent Dax wrote:
# > I suspect that the prototype for '..' is like this:
#
# So the 'step' use of colon may _only_ be used in conjunction with a
# "ranged" list, e.g. C<..>, correct? In _an
calling context is ambiguous, and any
wants_scalar/wants_list property be designed to accommodate this
(probably by specifying which one should be the default).
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test&quo
Garrett Goebel:
# Brent Dax wrote:
# >
# > This is also a problem with using want().
# >
# > If we don't provide wants_scalar/wants_list, someone will
# > build it with want(), so we might as well try to address
# > it. I suggest that want() return a special value when
# &
Garrett Goebel:
# From: Brent Dax [mailto:[EMAIL PROTECTED]]
# > Actually, I was thinking C, though a junction of all
# > the possible contexts might be good too. Remember, want()
# > is more than just scalar/array now.
#
# sure, sure...
#
# I was ambiguously referring back to Dan&
or
usage as well (at least within Parrot bytecode). I'm not sure about
disk space usage, but that's a pretty OS-level thing anyway.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God' t
ative code library X" is. That way the sysadmin or whoever can make
sure that only harmless libraries get in. The control mechanism could
be in Parrot_dlopen, which would make (well-behaved) native libraries
subject to it too.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot
s the last message I'm sending you from the list! ;^) )
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God' to "prove" it is who it says it is?
"If you're God, you
as that arrays would flatten implicity in list
context, and the splat was only to be used in cases like subroutine
calls, when an array would normally ref-ify.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" th
so I can't tell you for sure.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God' to "prove" it is who it says it is?
"If you're God, you know exactly what it would take to convince me. Do
that."
--Marc Fleury on alt.atheism
Tupshin Harper:
# If pxs is truly obsolete, please trash it ;-).
I'm not confident enough about PXS to trash it, but I've commented a few
files appropriately.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "
the
semantics of the language they were defined in, which to me seems to be
the right thing.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God' to "prove" it is who it says it is?
"If you're God, you know exactly what it would take to convince me. Do
that."
--Marc Fleury on alt.atheism
ren't exposed.
...
I honestly don't care much about such languages, but how is Parrot going
to support classless languages like JavaScript? Are such languages
going to have to fake it with anonymous classes, or will we make sure
that you don't *really* need a class behind an object
just be
# implemented in
# terms of automatically generated accessor functions.
The attribute slots in a Parrot object are private to the object (and,
by extension, any classes it is a member of), so access will be mediated
through accessors.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {&q
;method X is from(A)', would please me much more. The manpage can
strongly encourage use of 'is from' when there's MI afoot.
But we're in language territory again. Parrot has to deal with this
issue in a flexible way, so always emitting a fatal error is simply not
an op
e
# > manpage can strongly encourage use of 'is from' when
# there's MI afoot.
#
# It sounds like you already have a plan - I didn't realise
# about `is from'.
# I'll shut up on this subject now :-).
Ugh...sorry, that was rabid speculation on my part. I
named, [EMAIL PROTECTED]) { ... }
I can deal with one really funny character in a signature, but three is
a bit much.
In any case, it looks like it's time to re-work Perl6::Parameters...but
then I knew this was coming anyway.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_&q
Damian Conway:
# Brent Dax wrote:
#
# > method x ($me: $req, ?$opt, +$namedop, *%named, [EMAIL PROTECTED]) { ... }
# >
# > Yikes. And I thought we were trying to get *away* from
# line noise?
# > :^)
# >
# > Seriously, can't we use something rat
Simon Cozens:
# [EMAIL PROTECTED] (Luke Palmer) writes:
# > we have a definitive
# ^^
# Remember that this is Perl 6. You keep using that word, etc.
It *is* definitive, Simon...at least this week. ;^)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_&
een declared. But I assume you get the idea--you could
conceivably have Very Bad Things happen if Perl doesn't catch a
macromethod call.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test" this 'God&#x
default but easy to turn on.
[1] Perhaps this should be generalized to strict and loose coercion; I'm
not really sure yet. (Under strict coercion, adding an Int and a Str
would be an error, instead of coercing the Str into an Int.)
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot
their arguments in @_.
It also says that methods get their invocant in $_. In an unprototyped
method, is the invocant in $_, @_[0], both, or neither?
-What exactly does caller's $where parameter do? Does it specify a
starting point for the search?
--Brent Dax <[EMAIL PROTECTED]>
Unofficia
#x27;s gained?
# Then we could also use eq for real identity, if we wanted to.
Which is the more common operation, string equality or identity check?
Thought so.
--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)
>How do you "test&qu
how traits are implemented, (1) and (3) might be
# unified.
Who's to say they aren't all unified? If a trait is just a sort of base
class, and an instance of Scalar (the container) is seen as having its
own (anonymous) class, then all three are one and the same.
--Brent Dax <[
o
out of scope.
(Sorry about the formatting--I just reinstalled Windows, and I'm still
settling in here.)
--Brent Dax <[EMAIL PROTECTED]>
:Resumable that inherits from both
Exception and Continuation, but I don't think that normal exceptions can
or should be resumable.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
errors are unthrown exceptions--a normal
exception object sits in $!, but it's never thrown.)
I expect that in Perl 6 after an C error, $! will be set to an
exception of class X::Errno (or something like it); that class may have
overloaded prefix:+ and prefix:~ operators as necessary.
--Bren
loat handling. The call to snprintf is on spf_render.c:585.
[2] Or not compile. I'm not sure which Parrot currently does for
systems with no snprintf.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
"Yeah, and my underwear is flame-retardant--that doesn't mean I'm gonna
set myself on fire to prove it."
Leopold Toetsch:
# Brent Dax wrote:
# > First of all, spf_render.c:18-20:
# > /* Per Dan's orders, we will not use sprintf if snprintf isn't
# > * around for us.
# > */
# >
# > So we can't use vfprintf, unless Dan thinks otherwise.
#
# Sorry, I don
will automatically detect the new opcode files and include
them in the build, and a MANIFEST patch is also included. Test pass
rate is 96.49%, which is roughly as expected on my Windows 2000 system;
I don't know how well it works on a system with less "noise" in the
tests.
Please test
Brent Dax:
# Since I don't think it's polite to flood peoples' mailboxes, I have
# uploaded the 205 kb (9213 line) patch to
# <http://filespace.brentdax.com/brentdax/coresplit.diff>.
The version I originally posted contained a patch to classes/timer.pmc,
basically disablin
with such a big diff.
I encourage people to test it out and tell me both how well it works and
what they think of the arrangement.
TIA,
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
"Yeah, and my underwear is flame-retardant--that doesn't mean I'm gonna
set myself on fire to prove it."
The core.ops split has been committed. Documentation has been fixed up,
and all the copyright stuff should be correct.
Please remember to reassemble any Parrot bytecode files you currently
have.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
"Yeah, and my underwear is flam
doing this for
io.ops
# and core.ops (which just got a lot smaller).
This is probably a good idea.
I'd actually suggest combining them into one file--your_ops.pod or
somesuch--that covered all installed ops files, but the way the
documentation is formatted doesn't really lend itself to
s to start tracking those down.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
"Yeah, and my underwear is flame-retardant--that doesn't mean I'm gonna
set myself on fire to prove it."
know that it was working
fine before the exec stuff went in--perhaps looking at the diffs on jit.pl
will be enlightening. Unfortunately, I'm away from my home computer and I
don't have a C compiler or toolkit, so I can't work it out myself.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
Leopold Toetsch:
> To clean up on scope exit (and after a Perl C ins), the HL emits
> a C opcode. This doesn't do C anymore,
> because there is nothing unanchored and alive beyond the runloop's stack.
Have I mentioned lately that you guys are geniuses?
--Brent Dax <[EMAI
;t have a copy of the source
with me, and I'm writing this offline, so I can't tell you what the correct
constant is.
--Brent Dax <[EMAIL PROTECTED]>
Perl and Parrot hacker
201 - 300 of 891 matches
Mail list logo
