PETSCII spelling

docs/source/index.rst

@@ -69,7 +69,7 @@ Language features
 - Nested subroutines can access variables from outer scopes to avoids the overhead to pass everything via parameters
 - Variable data types include signed and unsigned bytes and words, arrays, strings.
 - Floating point math also supported if the target system provides floating point library routines (C64 and Cx16 both do).
-- Strings can contain escaped characters but also many symbols directly if they have a petscii equivalent, such as "♠♥♣♦π▚●○╳". Characters like ^, _, \\, {, } and | are also accepted and converted to the closest petscii equivalents.
+- Strings can contain escaped characters but also many symbols directly if they have a PETSCII equivalent, such as "♠♥♣♦π▚●○╳". Characters like ^, _, \\, {, } and | are also accepted and converted to the closest PETSCII equivalents.
 - High-level code optimizations, such as const-folding, expression and statement simplifications/rewriting.
 - Many built-in functions, such as ``sin``, ``cos``, ``abs``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``sort`` and ``reverse``
 - Programs can be run multiple times without reloading because of automatic variable (re)initializations.

docs/source/libraries.rst

@@ -186,10 +186,10 @@ Provides string manipulation routines.
     but this function is useful if you're dealing with addresses for instance.
 
 ``lower(string)``
-    Lowercases the petscii-string in place.
+    Lowercases the PETSCII-string in place.
 
 ``upper(string)``
-    Uppercases the petscii-string in place.
+    Uppercases the PETSCII-string in place.
 
 ``lowerchar(char)``
     Returns lowercased character.

docs/source/portingguide.rst

@@ -40,7 +40,7 @@ RAM, ROM, I/O
 
 Character encodings
 -------------------
-#. if not Petscii or CBM screencodes: provide the primary character encoding table that the system uses (i.e. how is text represented in memory)
+#. if not PETSCII or CBM screencodes: provide the primary character encoding table that the system uses (i.e. how is text represented in memory)
 #. provide alternate character encodings (if any)
 #. what are the system's standard character screen dimensions?
 #. is there a screen character matrix directly accessible in Ram? What's it address? Same for color attributes if any.

docs/source/programming.rst

@@ -230,7 +230,7 @@ Integers
 Integers are 8 or 16 bit numbers and can be written in normal decimal notation,
 in hexadecimal and in binary notation.
 A single character in single quotes such as ``'a'`` is translated into a byte integer,
-which is the Petscii value for that character.
+which is the PETSCII value for that character.
 
 Unsigned integers are in the range 0-255 for unsigned byte types, and 0-65535 for unsigned word types.
 The signed integers integers are in the range -128..127 for bytes,
@@ -341,7 +341,7 @@ Strings (without encoding prefix) will be encoded (translated from ASCII/UTF-8)
 Alternative encodings can be specified with a ``encodingname:`` prefix to the string or character literal.
 The following encodings are currently recognised:
 
-    - ``petscii``  Petscii, the default encoding on CBM machines (c64, c128, cx16)
+    - ``petscii``  PETSCII, the default encoding on CBM machines (c64, c128, cx16)
     - ``sc``  CBM-screencodes aka 'poke' codes (c64, c128, cx16)
     - ``iso``  iso-8859-15 text (supported on cx16)
 
@@ -452,9 +452,9 @@ Many type conversions are possible by just writing ``as <type>`` at the end of a
     f = 56.777
     ub = f as ubyte             ; ub will be 56
 
-Sometimes it is a straight 'type cast' where the value is simply interpreted as being of the other type,
-sometimes an actual value conversion is done to convert it into the targe type.
-Try to avoid type conversions as much as possible.
+Sometimes it is a straight reinterpretation of the given value as being of the other type,
+sometimes an actual value conversion is done to convert it into the other type.
+Try to avoid those type conversions as much as possible.
 
 
 Initial values across multiple runs of the program

docs/source/syntaxreference.rst

@@ -329,7 +329,7 @@ type identifier  type                     storage size       example var declara
 ``float[]``      floating-point array     depends on value   ``float[] myvar = [1.1, 2.2, 3.3, 4.4]``
 ``bool[]``       boolean array            depends on value   ``bool[] myvar = [true, false, true]``  note: consider using bit flags in a byte or word instead to save space
 ``str[]``        array with string ptrs   2*x bytes + strs   ``str[] names = ["ally", "pete"]``
-``str``          string (petscii)         varies             ``str myvar = "hello."``
+``str``          string (PETSCII)         varies             ``str myvar = "hello."``
                                                              implicitly terminated by a 0-byte
 ===============  =======================  =================  =========================================
 
@@ -342,7 +342,7 @@ value is given, the array size in the declaration can be omitted.
 Note that ``%`` is also the remainder operator so be careful: if you want to take the remainder
 of something with an operand starting with 1 or 0, you'll have to add a space in between.
 
-**character values:** you can use a single character in quotes like this ``'a'`` for the Petscii byte value of that character.
+**character values:** you can use a single character in quotes like this ``'a'`` for the PETSCII byte value of that character.
 
 
 **``byte`` versus ``word`` values:**
@@ -461,7 +461,7 @@ There are several escape sequences available to put special characters into your
 - ``\uHHHH`` - a unicode codepoint \u0000 - \uffff (16-bit hexadecimal)
 - ``\xHH`` - 8-bit hex value that will be copied verbatim *without encoding*
 
-- String literals can contain many symbols directly if they have a petscii equivalent, such as "♠♥♣♦π▚●○╳".
+- String literals can contain many symbols directly if they have a PETSCII equivalent, such as "♠♥♣♦π▚●○╳".
   Characters like ^, _, \\, {, } and | (that have no direct PETSCII counterpart) are still accepted and converted to the closest PETSCII equivalents. (Make sure you save the source file in UTF-8 encoding if you use this.)