develooper Front page | perl.cvs.parrot | Postings from December 2008

[svn:parrot] r34714 - trunk/docs/book

From:
bernhard
Date:
December 31, 2008 09:42
Subject:
[svn:parrot] r34714 - trunk/docs/book
Message ID:
20081231174154.021D0CB9FA@x12.develooper.com
Author: bernhard
Date: Wed Dec 31 09:41:53 2008
New Revision: 34714

Modified:
   trunk/docs/book/ch08_architecture.pod
   trunk/docs/book/ch09_pct.pod

Log:
RT #61874: [PATCH] Fixed typos in docs
Courtesy of tuxdna


Modified: trunk/docs/book/ch08_architecture.pod
==============================================================================
--- trunk/docs/book/ch08_architecture.pod	(original)
+++ trunk/docs/book/ch08_architecture.pod	Wed Dec 31 09:41:53 2008
@@ -733,10 +733,10 @@
 part of your process. Most programmers will better know SIGSEGV as a
 "segmentation fault", something that should be avoided at all costs.
 There's no good way for Parrot to catch and handle these signals, since
-the occur at a lower level in the operating system and are typically
+they occur at a lower level in the operating system and are typically
 presented to Parrot long after anything can be done about it. These
 signals will therefore always kill Parrot and whatever programs were
-running on t. On some systems it's possible to catch some of
+running on it. On some systems it's possible to catch some of
 N<sometimes> the fatal signals, but Parrot code itself operates at too
 high a level for a user program to do anything with them. Any handlers
 for these kinds of signals would have to be written at the lowest levels
@@ -854,7 +854,7 @@
 there's no need to lock anything.
 
 In the second threading model, multiple threads run and pass messages
-back and forth between each other. Parrot supports this as well, via
+back and forth amongst themselves. Parrot supports this as well, via
 the event mechanism. The event queues are thread-safe, so one thread
 can safely inject an event into another thread's event queue. This is
 similar to a multiple-process model of programming, except that
@@ -862,7 +862,7 @@
 around structured data.
 
 In the third threading model, multiple threads run and share data
-between themselves directly. While Parrot can't guarantee that data at
+among themselves directly. While Parrot can't guarantee that data at
 the user level remains consistent, it can make sure that access to shared
 data is at least safe. We do this with two mechanisms.
 
@@ -1011,8 +1011,7 @@
 Parrot classes. Being able to subclass C++ and Objective C classes is
 a potential bonus. Python, Ruby, and Perl 6 all share a common (but
 hidden) base class in Parrot's base object type, so they can inherit
-from each other without
-difficulty.
+from each other without difficulty.
 
 =head1 Advanced Features
 

Modified: trunk/docs/book/ch09_pct.pod
==============================================================================
--- trunk/docs/book/ch09_pct.pod	(original)
+++ trunk/docs/book/ch09_pct.pod	Wed Dec 31 09:41:53 2008
@@ -139,7 +139,7 @@
 they produce a top-level token.
 
 PGE itself is a top-down parser, although it also contains a bottom-up
-I<operator precidence> parser, for things like mathematical expressions
+I<operator precedence> parser, for things like mathematical expressions
 where bottom-up methods are more efficient. We'll discuss both, and the
 methods for switching between the two, throughout this chapter.
 
@@ -241,7 +241,7 @@
 first "Jar" as C<< <first_name> >> and the second "Jar" as
 C<< <last_name> >> and wouldn't match "Binks" at all.
 
-In PGE. The top-level rule which starts the match process and must
+In PGE, the top-level rule which starts the match process and must
 successfully match in order for the compiler to continue is always
 called C<TOP>. Without a TOP rule, your compiler won't do anything
 N<Actually, it will print out an error saying that you have no
@@ -430,7 +430,7 @@
 often for new language designers, and one that is not always likely to
 generate useful error messages.
 
-=head3 Operator Precidence Parser
+=head3 Operator Precedence Parser
 
 Places where there are lots of little tokens in a statement, and where
 there are lots of possible options that a top-down parser will have to
@@ -443,29 +443,29 @@
 The recursive descent parser is going to have to recognize through
 significant trial and error how this statement should be parsed. For tasks
 like this, recursive descent parsers are not ideal, although a type of
-bottom-up parser called an I<operator precidence>
-X<Parser, Operator precidence> parser is. Operator precidence parsers
+bottom-up parser called an I<operator precedence>
+X<Parser, Operator precedence> parser is. Operator precedence parsers
 work similarly to more versatile bottom-up parsers such as Lex or Yacc, but
 are optimized for use with expressions and equations. The "things" in an
 equation are split into two subtypes: I<terms> and I<operators>. Operators
 themselves are split into a number of types including postfix (C<-a>),
 suffix (C<i++>), infix (C<x + y>), circumfix (C<[z]>), postcircumix
-(C<a[b]>), and list (C<1, 2, 3>). Each operator gets its own precidence
+(C<a[b]>), and list (C<1, 2, 3>). Each operator gets its own precedence
 number that specifies how closely it binds to the terms. In the example above,
 the expression is parsed
 
  a + (b * c) + d
 
-This is because the C<*> operator has a higher precidence and therefore binds
+This is because the C<*> operator has a higher precedence and therefore binds
 more tightly then the C<+> operator.
 
 To switch from the top-down recursive descent parser to the bottom-up
-operator precidence parser, a rule must be defined that is an C<optable>
+operator precedence parser, a rule must be defined that is an C<optable>
 X<Parser, optable>:
 
  rule expression is optable { ... }
 
-The C<...> ellipses aren't an editorial shortcut, it's the perl 6 operator
+The C<...> ellipses aren't an editorial shortcut, it's the Perl 6 operator
 that is used to define a function signature. The C<...> indicates that
 this is just a signature and that the actual guts of it will be filled in
 somewhere else. In this case, that "somewhere else" is in the definition of
@@ -490,7 +490,7 @@
 location part and an identifier part. The location is one of the places where
 the operator can be located, such as infix, postfix, prefix, circumfix, and
 postcircumfix. The name of the operator is the symbol used for the operator in
-any of the quotes that Perl6 understands:
+any of the quotes that Perl 6 understands:
 
  proto infix:<+>                  # a + b
  proto postfix:'--'               # i--
@@ -499,8 +499,8 @@
 The C<is> X<Parser, is> keyword defines a property of the rule. Some examples of
 this are:
 
- is precidence(1)     # Specifies an exact precidence
- is equiv('+')        # Has the same precidence as the "+" operator
+ is precedence(1)     # Specifies an exact precedence
+ is equiv('+')        # Has the same precedence as the "+" operator
  is assoc('right')    # Right associative. May also be "left" or "list"
  is pirop('add')      # Operands are passed to the PIR operator "and"
  is subname('mySub')  # Operands are passed to the function "mySub"



nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About