# New Ticket Created by Nick Glencross
# Please include the string: [perl #34989]
# in the subject line of all future correspondence about this issue.
# <URL: https://rt.perl.org/rt3/Ticket/Display.html?id=34989 >
This patch fixes a few more typos. I'll leave it a few months before
doing this again.
I'm assuming that 'heisenbugs' is for real, that made me chuckle....
Cheers,
Nick
Index: src/embed.c
===================================================================
--- src/embed.c (revision 7833)
+++ src/embed.c (working copy)
@@ -62,7 +62,7 @@
Like above. Additionally sets the stack top, so that Parrot objects created
in inner stack frames will be visible during DODs stack walking code.
B<stack_top> should be the address of an automatic variable in the callers
-stack frame. All unachored Parrot objects (PMCs) must live in inner stack
+stack frame. All unanchored Parrot objects (PMCs) must live in inner stack
frames so that they are not destroyed during DOD runs.
Use this function, when you call into Parrot before entering a run loop.
@@ -647,7 +647,7 @@
/*
* walk the fixup table, the first Sub-like entry should be our
- * entry point with the address at our resoume_offset
+ * entry point with the address at our resume_offset
*/
pf = interpreter->code;
Index: src/runops_cores.c
===================================================================
--- src/runops_cores.c (revision 7833)
+++ src/runops_cores.c (working copy)
@@ -124,7 +124,7 @@
if (Interp_flags_TEST(interpreter, PARROT_TRACE_FLAG)) {
trace_i = make_interpreter(interpreter, NO_FLAGS);
Parrot_init(trace_i);
- /* remeber old context */
+ /* remember old context */
trace_ctx = mem_sys_allocate(sizeof(struct Parrot_Context));
mem_sys_memcopy(trace_ctx, &trace_i->ctx,
sizeof(struct Parrot_Context));
Index: src/gc_ims.c
===================================================================
--- src/gc_ims.c (revision 7833)
+++ src/gc_ims.c (working copy)
@@ -319,7 +319,7 @@
objects to another thread. After doing some increments of marking, these
objects then get returned to the shared to-space. The parallel
collection is finished when the last object is blackened and all threads
-have reached the thread barrier rendevous point. (Please note the very
+have reached the thread barrier rendezvous point. (Please note the very
different meaning of barrier here).
But also a single-threaded Parrot can vastly take advantage by running
Index: src/events.c
===================================================================
--- src/events.c (revision 7833)
+++ src/events.c (working copy)
@@ -372,7 +372,7 @@
ev->u.signal = signum;
entry->data = ev;
/*
- * deliver to all intrepreters
+ * deliver to all interpreters
*/
Parrot_schedule_broadcast_qentry(entry);
}
@@ -412,7 +412,7 @@
=item C<void
Parrot_new_cb_event(Parrot_Interp, PMC*cbi, void*ext)>
-Prepare and schedul a callback event
+Prepare and schedule a callback event
=cut
Index: src/cpu_dep.c
===================================================================
--- src/cpu_dep.c (revision 7833)
+++ src/cpu_dep.c (working copy)
@@ -16,7 +16,7 @@
by moving a virtual window up/down the register stack restricting the
number of registers which are visible.
-Remember you read somethng about it in F<docs/infant.dev>?
+Remember you read something about it in F<docs/infant.dev>?
=head2 Functions
Index: src/malloc.c
===================================================================
--- src/malloc.c (revision 7833)
+++ src/malloc.c (working copy)
@@ -1025,7 +1025,7 @@
arena: current total non-mmapped bytes allocated from system
ordblks: the number of free chunks
smblks: the number of fastbin blocks (i.e., small chunks that
- have been freed but not use resused or consolidated)
+ have been freed but not use reused or consolidated)
hblks: current number of mmapped regions
hblkhd: total bytes held in mmapped regions
usmblks: the maximum total allocated space. This will be greater
Index: src/string_primitives.c
===================================================================
--- src/string_primitives.c (revision 7833)
+++ src/string_primitives.c (working copy)
@@ -198,7 +198,7 @@
workchar += codepoint - 'A' + 10;
} else {
internal_exception(UNIMPLEMENTED,
- "Illegal escape sequence insidde {}");
+ "Illegal escape sequence inside {}");
}
}
if (*offset == len)
Index: src/library.c
===================================================================
--- src/library.c (revision 7833)
+++ src/library.c (working copy)
@@ -81,7 +81,7 @@
sub = Parrot_find_global(interpreter, str, name);
if (!sub) {
interpreter->resume_flag = resume;
- internal_exception(1, "unkown parrotlib method '%s'", func_name);
+ internal_exception(1, "unknown parrotlib method '%s'", func_name);
abort();
}
Index: src/mmd.c
===================================================================
--- src/mmd.c (revision 7833)
+++ src/mmd.c (working copy)
@@ -928,7 +928,7 @@
}
/*
* XXX invalidate S1
- * this is needed for this seqeuence:
+ * this is needed for this sequence:
* "__add"(l, r, d) # multi sub call - create S1
* m = getattribute l, "__add" # create bound method
* m(r, d)
@@ -1022,7 +1022,7 @@
type1 = VTABLE_get_integer_keyed_int(interpreter, arg_tuple, 0);
if (type1 < 0) {
return;
- internal_exception(1, "unimplemted native MMD type");
+ internal_exception(1, "unimplemented native MMD type");
/* TODO create some class namespace */
}
else {
Index: src/packfile.c
===================================================================
--- src/packfile.c (revision 7833)
+++ src/packfile.c (working copy)
@@ -2732,7 +2732,7 @@
Delete the C<PackFile_Constant> C<self>.
-Dont't delete C<PMC>s or C<STRING>s, they are destroyed via DOD/GC.
+Don't delete C<PMC>s or C<STRING>s, they are destroyed via DOD/GC.
=cut
Index: src/exceptions.c
===================================================================
--- src/exceptions.c (revision 7833)
+++ src/exceptions.c (working copy)
@@ -232,7 +232,7 @@
if (e->entry_type == STACK_ENTRY_ACTION) {
/*
* Clear automatic cleanup routine run in stack_pop
- * and run the action sburoutine with an INTVAL argument
+ * and run the action subroutine with an INTVAL argument
* of 1
*/
PMC *sub = UVal_pmc(e->entry);
Index: docs/ROADMAP
===================================================================
--- docs/ROADMAP (revision 7833)
+++ docs/ROADMAP (working copy)
@@ -169,7 +169,7 @@
=item *
- requestor: leo
+ requester: leo
Ok. In the long run I expect a multi-stage config system. First is to
get miniparrot built and running, then Parrot core. Extensions like gdbm
Index: docs/debug.pod
===================================================================
--- docs/debug.pod (revision 7833)
+++ docs/debug.pod (working copy)
@@ -57,7 +57,7 @@
Within the C<--gc-debug> mode, there is another tool to help narrow down the
problem. You can edit F<src/dod.c> and C<#define> the C<GC_VERBOSE> flag to 1.
-After recompiling C<parrot>, the garbage collecter will perform additional
+After recompiling C<parrot>, the garbage collector will perform additional
checks. After the garbage collector has traced all objects to find which
ones are still alive, it will scan through all of the dead objects to see
if any of them believe they are alive (which will happen for infants, since
Index: docs/porting_intro.pod
===================================================================
--- docs/porting_intro.pod (revision 7833)
+++ docs/porting_intro.pod (working copy)
@@ -7,7 +7,7 @@
=head1 OVERVIEW
-This document is an introduction to porting the optional subsytems of Parrot
+This document is an introduction to porting the optional subsystems of Parrot
onto a new architecture once the core successfully builds. It assumes passing
familiarity with common VM techniques but relatively little knowledge of Parrot
internals. For each feature, a brief description of its purpose, hints on
Index: docs/dev/nanoparrot.c
===================================================================
--- docs/dev/nanoparrot.c (revision 7833)
+++ docs/dev/nanoparrot.c (working copy)
@@ -73,7 +73,7 @@
/*
* some macros to get 3 different kinds of run loops
- * you might skip this uglyness and continue
+ * you might skip this ugliness and continue
* at dispatch loop ~90 lines below
*
* or for the curious: look at the preprocessor output
Index: docs/dev/rx.dev
===================================================================
--- docs/dev/rx.dev (revision 7833)
+++ docs/dev/rx.dev (working copy)
@@ -180,7 +180,7 @@
This section describes the use of bitmaps in rx.[ch] and briefly
describes the other possible choices and why bitmaps are used over them.
The advantage to using bitmaps is both in speed and storage. After
-bitmaps started being used, there was a noticable speed increase.
+bitmaps started being used, there was a noticeable speed increase.
=over 4
@@ -224,7 +224,7 @@
we ignore the 3 least significant bits of each number in the range 0-255,
than for every number, there will be 7 others that are the same as it
(since for each permutation of the 5 most significant bits, there are 8
-possibilites for the 3 least significant bits). Now all we need to do is
+possibilities for the 3 least significant bits). Now all we need to do is
ignore the 3 least significant digits, and at the same time produce a
number in the range 0-31. The quickest way to do this is just to right
shift a number 3 places, making the 3 least significant digits "fall
Index: ops/python.ops
===================================================================
--- ops/python.ops (revision 7833)
+++ ops/python.ops (working copy)
@@ -15,7 +15,7 @@
=head1 DESCRIPTION
-Currently included in main - will be splitted.
+Currently included in main - will be split.
=cut
@@ -42,7 +42,7 @@
=item B<print_newline>()
-Print a newline char to standar output.
+Print a newline char to standard output.
=cut
Index: ops/core.ops
===================================================================
--- ops/core.ops (revision 7833)
+++ ops/core.ops (working copy)
@@ -1161,7 +1161,7 @@
if (p == NULL) {
const char * err = Parrot_dlerror();
Parrot_warn(interpreter, PARROT_WARNINGS_UNDEF_FLAG,
- "Symbol '%s' not found: %s\n", name, err ? err : "unkown reason");
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
$1 = pmc_new(interpreter, enum_class_Undef);
}
else {
@@ -1180,7 +1180,7 @@
if (p == NULL) {
const char * err = Parrot_dlerror();
Parrot_warn(interpreter, PARROT_WARNINGS_UNDEF_FLAG,
- "Symbol '%s' not found: %s\n", name, err ? err : "unkown reason");
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
$1 = pmc_new(interpreter, enum_class_Undef);
}
else {
Index: ops/rx.ops
===================================================================
--- ops/rx.ops (revision 7833)
+++ ops/rx.ops (working copy)
@@ -527,7 +527,7 @@
at the current position of the string. So when the overall match fails,
you\'ll have to increment start_index by hand before calling them.
-Additonally, this ops can be used to optimize matches of the type:
+Additionally, this ops can be used to optimize matches of the type:
.*? <pattern> # non-greedy repetition of dot, followed by
# a known pattern
@@ -835,7 +835,7 @@
As we will see, most of the rx opcodes read or modify at least one of
this registers. Sometimes, the compiler can decide to use some other
registers, to save temporary information about the match (like the
-position of the begining of a group, for example).
+position of the beginning of a group, for example).
Let's start with a really simple regex. Imagine that we want to
compile the code
@@ -858,7 +858,7 @@
Let's look at this instructions one at-a-time.
start:
- ## we start matching from the begining of the match
+ ## we start matching from the beginning of the match
set I0, 0
## match the string "foobar" at the current position, or branch to end
@@ -898,12 +898,12 @@
start-of-match position by one and try again. When there are no
characters left, rx_advance branches to $fail.
-This is the scheleton of how regexes work in general. The main loop
+This is the skeleton of how regexes work in general. The main loop
iterates over I0 (start-of-match) while the inner ops update I1
(match-position).
For this particular case, Rx4 offers an specialized op that can be used
-to optimize the computation. C<rx_search> merges the funcionality of
+to optimize the computation. C<rx_search> merges the functionality of
C<rx_advance> and C<rx_literal> in one op.
Using this new op, the code to match would look like:
@@ -1011,7 +1011,7 @@
=item C<x|y|z>
start:
- set I2, I1 #I2 the begining of the group
+ set I2, I1 #I2 the beginning of the group
set I3, -6 #I3 next alternation in the group, expressed
#as an offset from the branch point
@@ -1081,7 +1081,7 @@
=item *
-There are undoubtably many more in code this complicated.
+There are undoubtedly many more in code this complicated.
=back
Index: ops/set.ops
===================================================================
--- ops/set.ops (revision 7833)
+++ ops/set.ops (working copy)
@@ -245,7 +245,7 @@
=item B<deref>(out PMC, in PMC)
-Not strictly an assigment operation: Get the PMC into $1, that the
+Not strictly an assignment operation: Get the PMC into $1, that the
reference PMC $2 refers to.
=cut
Index: ops/io.ops
===================================================================
--- ops/io.ops (revision 7833)
+++ ops/io.ops (working copy)
@@ -120,7 +120,7 @@
Perform an operation an an IO object. This is a general purpose
hook for setting various flags, modes, etc.
-Examples: setting the record seperator or setting the buffering
+Examples: setting the record separator or setting the buffering
=cut
Index: NEWS
===================================================================
--- NEWS (revision 7833)
+++ NEWS (working copy)
@@ -41,7 +41,7 @@
- String iterators
- String bitwise vtables
- Many new opcodes
- - Suppport for JIT, where malloced memory isn't executable
+ - Support for JIT, where malloced memory isn't executable
- Priority DOD scheme for objects that need timely destruction
- Improved byte code loading (e.g. onLoad functions)
- Language updates: forth, Perl6/P6C, m4
Index: classes/sharedref.pmc
===================================================================
--- classes/sharedref.pmc (revision 7833)
+++ classes/sharedref.pmc (working copy)
@@ -185,7 +185,7 @@
=item C<PMC* get_pmc()>
-Catch dereferencing. This would unshare the refered PMC.
+Catch dereferencing. This would unshare the referred PMC.
=cut
@@ -205,8 +205,8 @@
=item C<void destroy()>
-Destroys the refered object and itself. This probably nees destroy oderdering
-or at least a detection if the refered PMC is already destroyed.
+Destroys the referred object and itself. This probably needs destroy ordering
+or at least a detection if the referred PMC is already destroyed.
=cut
Index: classes/continuation.pmc
===================================================================
--- classes/continuation.pmc (revision 7833)
+++ classes/continuation.pmc (working copy)
@@ -40,7 +40,7 @@
* A Continuation (and RetContinuation, Exception_Handler) has in its
* context a pointer to the register frame, which contains active objects.
* Additionally ct->current_cont has he continuation of the caller.
- * To avoid deep recusrion during marking of nested subroutines, we
+ * To avoid deep recursion during marking of nested subroutines, we
* need the next_for_GC pointer in the pmc_ext area.
*/
Index: classes/ref.pmc
===================================================================
--- classes/ref.pmc (revision 7833)
+++ classes/ref.pmc (working copy)
@@ -110,7 +110,7 @@
*/
void init_pmc (PMC* initializer) {
- PMC_pmc_val(SELF) = initializer; /* the refered PMC itself */
+ PMC_pmc_val(SELF) = initializer; /* the referred PMC itself */
PObj_custom_mark_SET(SELF);
if (initializer) {
/*
Index: classes/random.pmc
===================================================================
--- classes/random.pmc (revision 7833)
+++ classes/random.pmc (working copy)
@@ -87,7 +87,7 @@
=item C<INTVAL get_integer_keyed_int(INTVAL max)>
-Returns a ramdom integer in the range C<0..max>.
+Returns a random integer in the range C<0..max>.
=cut
@@ -101,7 +101,7 @@
=item C<FLOATVAL get_number()>
-Returns a ramdom floating-point number in the range C<0.0..1.0>.
+Returns a random floating-point number in the range C<0.0..1.0>.
=cut
Index: classes/fixedpmcarray.pmc
===================================================================
--- classes/fixedpmcarray.pmc (revision 7833)
+++ classes/fixedpmcarray.pmc (working copy)
@@ -228,7 +228,7 @@
=item C<STRING *get_repr()>
-Returns a string representaion of the array contents.
+Returns a string representation of the array contents.
TODO implement freeze/thaw and use that instead.
=cut
Index: classes/float.pmc
===================================================================
--- classes/float.pmc (revision 7833)
+++ classes/float.pmc (working copy)
@@ -389,7 +389,7 @@
void divide (PMC* value, PMC* dest) {
MMD_Float: {
- /* TODO zero dividde */
+ /* TODO zero divide */
VTABLE_set_number_native(INTERP, dest,
PMC_num_val(SELF) / PMC_num_val(value));
}
@@ -442,7 +442,7 @@
void cmodulus (PMC* value, PMC* dest) {
MMD_Float: {
- /* TODO zero dividde */
+ /* TODO zero divide */
FLOATVAL f = PMC_num_val(value);
VTABLE_set_number_native(INTERP, dest,
fmod(PMC_num_val(SELF), f));
@@ -496,7 +496,7 @@
void modulus (PMC* value, PMC* dest) {
MMD_Float: {
- /* TODO zero dividde */
+ /* TODO zero divide */
FLOATVAL f = PMC_num_val(value);
VTABLE_set_number_native(INTERP, dest,
floatval_mod(PMC_num_val(SELF), f));
Index: classes/perlundef.pmc
===================================================================
--- classes/perlundef.pmc (revision 7833)
+++ classes/perlundef.pmc (working copy)
@@ -60,7 +60,7 @@
=item C<STRING *get_string()>
-Warns of the use of an unitialized value, and returns an empty Parrot
+Warns of the use of an initialized value, and returns an empty Parrot
string.
=cut
@@ -77,7 +77,7 @@
=item C<PMC *get_pmc()>
-Warns of the use of an unitialized value, and returns itself.
+Warns of the use of an initialized value, and returns itself.
=cut
@@ -535,7 +535,7 @@
=item C<void concatenate_str(STRING *value, PMC *dest)>
-All these methods warn of the use of an unitialized value, and return
+All these methods warn of the use of an initialized value, and return
the calculated result in C<*dest>.
In the division methods exceptions are raised for division by zero,
Index: classes/default.pmc
===================================================================
--- classes/default.pmc (revision 7833)
+++ classes/default.pmc (working copy)
@@ -806,7 +806,7 @@
=item C<PMC* get_attr_str(STRING* attr)>
-Look for NCI methods and propertys.
+Look for NCI methods and properties.
=cut
Index: README
===================================================================
--- README (revision 7833)
+++ README (working copy)
@@ -31,7 +31,7 @@
For most of the platforms that we are supporting initially,
Parrot should build out of the box.
-The list of targetted platforms can be found in PLATFORMS.
+The list of targeted platforms can be found in PLATFORMS.
The current configure system is primitive, as it's only
a temporary solution. It will be happy with most any answers
Index: dynclasses/gdbmhash.pmc
===================================================================
--- dynclasses/gdbmhash.pmc (revision 7833)
+++ dynclasses/gdbmhash.pmc (working copy)
@@ -24,13 +24,13 @@
=head2 store
-PMC insert values are convered to STRINGs.
+PMC insert values are converted to STRINGs.
TODO: Integer insert values are converted to STRINGs.
TODO: Number insert values are converted to STRINGs.
=head2 fetch
-get_integer_keyed() and get_number_keyed() make propably no sense,
+get_integer_keyed() and get_number_keyed() probably don't make any sense,
as integers usually can't be converted.
When a PMC is requested, a String PMC is returned.
Index: dynclasses/pybuiltin.pmc
===================================================================
--- dynclasses/pybuiltin.pmc (revision 7833)
+++ dynclasses/pybuiltin.pmc (working copy)
@@ -98,7 +98,7 @@
item = VTABLE_get_pmc_keyed_str(interpreter, stash, key);
if (item->vtable->base_type == enum_class_NCI) {
- /* Parrots MMD system needs the origial NCI type
+ /* Parrots MMD system needs the original NCI type
* make a clone of it
*/
if (string_ord(interpreter, key, key->strlen - 1) != '_') {
@@ -195,7 +195,7 @@
=item C<PMC* "__load__"()>
This is unabashed hackery scaffolding. It copies all the builtins
-functions from globals to lexicaly scoped variables.
+functions from globals to lexically scoped variables.
=cut
Index: dynclasses/pylong.pmc
===================================================================
--- dynclasses/pylong.pmc (revision 7833)
+++ dynclasses/pylong.pmc (working copy)
@@ -8,7 +8,7 @@
=head1 DESCRIPTION
-C<PyLong> provides arbitray precision integer mathematic functions.
+C<PyLong> provides arbitrary precision integer mathematic functions.
=head2 Functions
