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

[allison at svn.parrot.org]

Author: allison
Date: Sun Feb  8 21:27:42 2009
New Revision: 36477
URL: https://trac.parrot.org/parrot/changeset/36477

Log:
[doc] Redubbing "PMC"s.

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

Modified: trunk/docs/book/ch05_pasm.pod
==============================================================================
--- trunk/docs/book/ch05_pasm.pod	Sun Feb  8 21:25:00 2009	(r36476)
+++ trunk/docs/book/ch05_pasm.pod	Sun Feb  8 21:27:42 2009	(r36477)
@@ -244,7 +244,7 @@
 
 Z<CHP-5-SECT-2.2.2>
 
-X<PMCs (Parrot Magic Cookies);object types>
+X<PMCs (Polymorphic Containers);object types>
 Internally, PMC types are represented by positive integers, and
 built-in types by negative integers. PASM provides two opcodes to deal
 with types. Use C<typeof> to look up the name of a type from its
@@ -262,7 +262,7 @@
 
 In this example, C<typeof> returns the type name "String".
 
-X<PMCs (Parrot Magic Cookies);inheritance>
+X<PMCs (Polymorphic Containers);inheritance>
 X<Parrot;classes;inheritance>
 X<inheritance;with PMCs>
 All Parrot classes inherit from the class C<default>. The
@@ -337,7 +337,7 @@
   mul P0, P1, I2
   mul P0, P1, N2
 
-X<PMCs (Parrot Magic Cookies);operations on>
+X<PMCs (Polymorphic Containers);operations on>
 Operations on a PMC are implemented by the vtable method of the
 destination (in the two-argument form) or the left source argument (in
 the three argument form). The result of an operation is entirely
@@ -456,7 +456,7 @@
 to the new string. The second C<concat> concatenates "xy" onto the
 string "abcd" in C<S0> and stores the new string in C<S1>.
 
-X<PMCs (Parrot Magic Cookies);concatenation>
+X<PMCs (Polymorphic Containers);concatenation>
 For PMC registers, C<concat> has only a three-argument form with
 separate registers for source and destination:
 
@@ -1182,8 +1182,8 @@
 
 Z<CHP-5-SECT-3>
 
-In most of the examples we've shown so far, X<PMCs (Parrot Magic
-Cookies);working with> PMCs just duplicate the functionality of
+In most of the examples we've shown so far, X<PMCs (Polymorphic
+Containers);working with> PMCs just duplicate the functionality of
 integers, numbers, and strings. They wouldn't be terribly useful if
 that's all they did, though. PMCs offer several advanced features,
 each with its own set of operations.
@@ -1193,7 +1193,7 @@
 Z<CHP-5-SECT-3.1>
 
 PMCs can define complex types that hold multiple values. These are
-commonly called "X<PMCs (Parrot Magic Cookies);aggregate>
+commonly called "X<PMCs (Polymorphic Containers);aggregate>
 X<aggregate PMCs> aggregates." The most important feature added for
 aggregates is keyed access. Elements within an aggregate PMC can be
 stored and retrieved by a numeric or string key. PASM also offers a
@@ -1208,7 +1208,7 @@
 
 Z<CHP-5-SECT-3.1.1>
 
-X<PMCs (Parrot Magic Cookies);arrays>
+X<PMCs (Polymorphic Containers);arrays>
 The C<Array>X<Array PMC> PMC is an ordered aggregate with
 zero-based integer keys. The syntax for X<keyed access to PMCs> keyed access to a
 PMC puts the key in square brackets after the register name:
@@ -1250,7 +1250,7 @@
 
 Z<CHP-5-SECT-3.1.2>
 
-X<PMCs (Parrot Magic Cookies);hashes>
+X<PMCs (Polymorphic Containers);hashes>
 The C<Hash>X<Hash PMC> PMC is an unordered aggregate with
 string keys:
 
@@ -1332,7 +1332,7 @@
 
 Z<CHP-5-SECT-3.1.4>
 
-X<PMCs (Parrot Magic Cookies);data structures>
+X<PMCs (Polymorphic Containers);data structures>
 Arrays and hashes can hold any data type, including other aggregates.
 Accessing elements deep within nested data structures is a common
 operation, so PASM provides a way to do it in a single instruction.
@@ -1362,8 +1362,8 @@
 
 Z<CHP-5-SECT-3.2>
 
-We mentioned before that C<set> on two X<PMCs (Parrot Magic
-Cookies);assignment> PMCs simply aliases them both to the same object,
+We mentioned before that C<set> on two X<PMCs (Polymorphic
+Containers);assignment> PMCs simply aliases them both to the same object,
 and that C<clone> creates a complete duplicate object. But if you just
 want to assign the value of one PMC to another PMC, you need the
 C<assign>X<assign opcode (PASM)> opcode:
@@ -1394,7 +1394,7 @@
 
 Z<CHP-5-SECT-3.3>
 
-X<PMCs (Parrot Magic Cookies);properties>
+X<PMCs (Polymorphic Containers);properties>
 PMCs can have additional values attached to them as "properties" of
 the PMC. What these properties do is entirely up to the language being
 implemented. Perl 6 uses them to store extra information about a

Modified: trunk/docs/book/ch08_architecture.pod
==============================================================================
--- trunk/docs/book/ch08_architecture.pod	Sun Feb  8 21:25:00 2009	(r36476)
+++ trunk/docs/book/ch08_architecture.pod	Sun Feb  8 21:27:42 2009	(r36477)
@@ -819,7 +819,7 @@
 but trust us when we say it's something worth being concerned with.
 
 X<Parrot;native data type;;(see PMCs)>
-X<PMCs (Parrot Magic Cookies);Parrot's native data type> 
+X<PMCs (Polymorphic Containers);Parrot's native data type> 
 PMCs are complex structures, even the simplest ones. We can't count on
 the hardware or even the operating system to provide us atomic access.
 Parrot has to provide that atomicity itself, which is expensive. Getting
@@ -901,7 +901,7 @@
 
 Z<CHP-8-SECT-5.1>
 
-X<PMCs (Parrot Magic Cookies);handling method calls>
+X<PMCs (Polymorphic Containers);handling method calls>
 Parrot's object system is very simple--in fact, a PMC only has to handle
 method calls to be considered an object. Just handling methods covers
 well over 90% of the object functionality that most programs use, since
@@ -1038,7 +1038,7 @@
 has some strict rules over what can be referenced and from where.
 This allows it to have a more efficient garbage collection system.
 
-X<PMCs (Parrot Magic Cookies);garbage collection and>
+X<PMCs (Polymorphic Containers);garbage collection and>
 X<garbage collection;Parrot;PMC and>
 The first allocation system is responsible for PMC and string
 structures. These are fixed-sized objects that Parrot allocates out of