[svn:parrot] r37118 - trunk/docs/book
Util at svn.parrot.org
Util at svn.parrot.org
Thu Mar 5 05:20:22 UTC 2009
Author: Util
Date: Thu Mar 5 05:20:21 2009
New Revision: 37118
URL: https://trac.parrot.org/parrot/changeset/37118
Log:
[book] Typos in docs/book/ch*.pod
afficianados
consonent
constucts
continution
encapuslated
insideous
lanuages
occurance
parallism
represention
specifed
stuctures
untennable
unweildy
utlities
Modified:
trunk/docs/book/ch03_pir_basics.pod
trunk/docs/book/ch04_pir_subroutines.pod
trunk/docs/book/ch05_pasm.pod
trunk/docs/book/ch06_library.pod
trunk/docs/book/ch08_architecture.pod
trunk/docs/book/ch09_pct.pod
trunk/docs/book/ch10_hlls.pod
Modified: trunk/docs/book/ch03_pir_basics.pod
==============================================================================
--- trunk/docs/book/ch03_pir_basics.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch03_pir_basics.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -74,7 +74,7 @@
or C<for> loops. PIR has some support for basic C<if> branching constructs,
but will not support more complicated C<if>/C<then>/C<else> branch
structures. Because of these omissions PIR can become a little bit messy
-and unweildy for large programs. Luckily, there are a large group of
+and unwieldy for large programs. Luckily, there are a large group of
high-level languages (HLL) that can be used to program Parrot instead. PIR
is used primarily to write the compilers and libraries for these languages,
while those languages can be used for writing larger and more complicated
Modified: trunk/docs/book/ch04_pir_subroutines.pod
==============================================================================
--- trunk/docs/book/ch04_pir_subroutines.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch04_pir_subroutines.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -189,7 +189,7 @@
Sometimes there are parameters to a function that don't always need to be
passed, or values for a parameter which should be given a default value
if a different value hasn't been explicitly provided. Parrot provides
-a mechanism for allowing optional parameters to be specifed, so an
+a mechanism for allowing optional parameters to be specified, so an
error won't be raised if the parameter isn't provided. Parrot also
provides a flag value that can be tested to determine if an optional
parameter has been provided or not, so a default value can be supplied.
@@ -352,7 +352,7 @@
coroutine calls, are performed using continuations. This mechanism
is mostly hidden from developers who build applications on top of
Parrot. The power and flexibility is available if people want to use
-it, but it's hidden behind more familiar constucts if not.
+it, but it's hidden behind more familiar constructs if not.
Doing all sorts of flow control using continuations is called
X<Continuation Passing Style;CPS> Continuation Passing Style (CPS).
@@ -379,13 +379,13 @@
returned. We can optimize this situation if we realize that the second call to
C<add_one> is returning to the same place that C<add_two> is, and therefore
can utilize the same return continuation as C<add_two> uses. The two
-subroutine calls can share a return continution, instead of having to create
+subroutine calls can share a return continuation, instead of having to create
a new continuation for each call.
X<.tailcall directive>
In PIR code, we use the C<.tailcall> directive to make a tailcall like this,
instead of the C<.return> directive. C<.tailcall> performs this optimization
-by reusing the return continution of the parent function to make the
+by reusing the return continuation of the parent function to make the
tailcall. In PIR, we can write this example:
.sub main :main
@@ -1208,7 +1208,7 @@
distance to each variant, it calls the function with the lowest distance.
Notice that it's possible to define a variant that is impossible to call:
for every potential combination of arguments there is a better match. This
-isn't necessarily a common occurance, but it's something to watch out for
+isn't necessarily a common occurrence, but it's something to watch out for
in systems with a lot of multis and a limited number of data types in use.
=cut
Modified: trunk/docs/book/ch05_pasm.pod
==============================================================================
--- trunk/docs/book/ch05_pasm.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch05_pasm.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -1542,7 +1542,7 @@
instead of just by register or stack location. These languages also
have global variables, which are visible throughout the entire
program. Storing a global variable in a register would either tie up
-that register for the lifetime of the program or require some unweildy way
+that register for the lifetime of the program or require some unwieldy way
to shuffle the data into and out of registers.
Parrot provides structures for storing both global and lexically
@@ -2007,7 +2007,7 @@
Within the Parrot interpreter there are currently three registered
languages: C<PASM>, C<PIR>, and C<PASM1>. The first two are for parrot
-assembly language and parrot intermediate represention code. The third
+assembly language and parrot intermediate representation code. The third
is for evaluating single statements in PASM. Parrot automatically adds
an C<end> opcode at the end of C<PASM1> strings before they're
compiled.
Modified: trunk/docs/book/ch06_library.pod
==============================================================================
--- trunk/docs/book/ch06_library.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch06_library.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -7,7 +7,7 @@
PIR and PASM are both very low-level languages by any programming
standards, even though they support some important features of
high-level dynamic languages,and PIR has some symbolic syntax features.
-Important re-occurring programming tasks in these lanuages have been
+Important re-occurring programming tasks in these languages have been
extracted out into a series of runtime libraries to help make these
tasks easier. Libraries written in PIR or PASM can be easily included
and used from any of the high-level language compilers that target
@@ -57,7 +57,7 @@
=head1 NCI Wrapper Libraries
Parrot does not intend to reinvent any wheels, and there is lots of important
-functionality encapuslated in various libraries that Parrot does not copy.
+functionality encapsulated in various libraries that Parrot does not copy.
Instead of having to reimplement all sorts of libraries for Parrot, Parrot
provides the NCI interface to work with these libraries directly. PIR or
PASM wrapper libraries are provided to create an interface that programs
Modified: trunk/docs/book/ch08_architecture.pod
==============================================================================
--- trunk/docs/book/ch08_architecture.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch08_architecture.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -778,7 +778,7 @@
execute simultaneously. It's a relatively easy way to get some
parallelism without too much work. Threads don't solve all the
parallelism problems your program may have N<And in fact, threading
-can cause its own parallism problems, if you aren't careful>.
+can cause its own parallelism problems, if you aren't careful>.
Sometimes multiple processes on a single system, multiple processes
on a cluster, or processes on multiple separate systems are better
for parallelized tasks then using threads.
@@ -802,7 +802,7 @@
depending on which thread wrote to the memory location last. Composite
data structures, on the other hand, are not handled atomically. Two
threads both accessing a large data structure can write incompatible data
-into different fields. To avoid this, these stuctures can be protected
+into different fields. To avoid this, these structures can be protected
with special devices called mutexes. Mutexes N<depending on the exact
implementation and semantics, Mutexes can also be known as locks,
spinlocks, semaphores, or critical sections.> are special structures that
Modified: trunk/docs/book/ch09_pct.pod
==============================================================================
--- trunk/docs/book/ch09_pct.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch09_pct.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -85,7 +85,7 @@
=head3 C<make_language_shell.pl>
The Parrot repository contains a number of helpful utilities for doing
-some common development and building tasks with Parrot. These utlities
+some common development and building tasks with Parrot. These utilities
are all currently written in Perl 5, although in future releases the
majority will likely be built in Perl 6 and run on Parrot directly. This
is a bootstrapping problem that the developers have not tackled yet.
@@ -384,7 +384,7 @@
The intention is that if there is only one digit, we match the second
option in the alternation, and if there are more digits we can match
them recursively in the first alternation. However, take a close look
-at the insideous result. The recursive descent parser enters the C<list>
+at the insidious result. The recursive descent parser enters the C<list>
rule. It's first option is to enter the list rule again, so it does.
Recursive descent is a depth-first algorithm, and it will continue to
descent down a particular path until it finds a successful match or a
@@ -576,7 +576,7 @@
Like Perl, NQP uses sigils to differentiate different types of variables.
The C<$> sigil is used for scalars, C<@> is used for arrays, and C<%> is
-used for hashes N<Perl 6 afficianados will know that this isn't entirely
+used for hashes N<Perl 6 aficionados will know that this isn't entirely
true, but an in-depth look at Perl 6's context awareness is another topic
for another book>. A "scalar" is really any single value, and can
interchangably be given a string value, or an integer value, or an object.
@@ -678,12 +678,12 @@
if we have the input "A A A B B", and the following rule:
rule letters {
- <vowel>* <consonent>*
+ <vowel>* <consonant>*
}
The match object will look like this (in Perl 5 syntax):
- $/ = ("vowel" => ["A", "A", "A"], "consonent" => ["B", "B"])
+ $/ = ("vowel" => ["A", "A", "A"], "consonant" => ["B", "B"])
We can get the number of matches in each group by casting it to a scalar
using the C<$( )> operator:
Modified: trunk/docs/book/ch10_hlls.pod
==============================================================================
--- trunk/docs/book/ch10_hlls.pod Thu Mar 5 04:08:27 2009 (r37117)
+++ trunk/docs/book/ch10_hlls.pod Thu Mar 5 05:20:21 2009 (r37118)
@@ -176,7 +176,7 @@
work well. Now, expand this to all the languages on Parrot. We would need
wrappers or converters to allow every pair of languages to communicate,
which requires C<N^2> libraries to make it work! As the number of languages
-hosted on the platform increases, this clearly becomes an untennable
+hosted on the platform increases, this clearly becomes an untenable
solution.
So, what do we do? How do we make very different languages like Common
More information about the parrot-commits
mailing list