Path: utzoo!utgpu!news-server.csri.toronto.edu!rpi!zaphod.mps.ohio-state.edu!wuarchive!rex!uflorida!gatech!usenet.ins.cwru.edu!ysub!psuvm!art100
From: ART100@psuvm.psu.edu (Andy Tefft)
Newsgroups: comp.binaries.apple2
Subject: LISA Assembler docs (2 of 3)
Message-ID: <91128.205737ART100@psuvm.psu.edu>
Date: 9 May 91 00:57:37 GMT
Organization: Penn State University
Lines: 578

MISC. ASSEMBLER DIRECTIVES

The CON (constant) directive is currently a synonym for EQU.  However, in
future versions of LISA v3.x, a label defined with the CON directive will
only be allowed within immediate expressions or within an address expression
for a pseudo-opcode.  You should not use CON to define variable names.   The
intent of the CON directive is to help make your programs more readable.

The CON directive instantly identifies a label as a constant, not a variable
in memory or the entry point of some subroutine.  By using CON for constants
and EPZ/EQU for variables and entry points, you can make your programs much
easier to read and understand.  Most 6502 assembly language programmers
define all of their zero page labels at the beginning of the program before
they are encountered within an address expression.  This geography is
considered good programming style.  Although there is probably no reason why
you cannot always define a zero page label (using the EPZ pseudo-opcode)
before the label is encountered within a program, a special pseudo-opcode,
FZR, is included in LISA v3.x's repertoire to allow you to state that a
symbol is zero page without defining its value before it is used.

This pseudo-opcode is especially useful when converting certain LISA v2.6
programs to LISA v3.x.

The FZR (Forward Zero page Reference) assembler directive is used to define a
zero page label without assigning a value to it.  LISA v3.x is a two-pass
assembler (LISA v2.6 was a three pass assembler) and it assumes that
undefined labels are absolute.  If a zero page label is defined with the  EPZ
directive after that label was already encountered in the source file, LISA
v3.x will give you an error.  To correct this problem, either move the zero
page definition to the beginning of the source file (if practical or
possible) or use the FZR assembler directive to define the label as zero page
before the label is used.  The syntax for the FZR directive is:

FZR <label>

<label> must not have been previous defined.

If you do not understand why FZR is required, consider the following program
sequence:

        ORG        $800
        LDA        ZPG
LBL     LDX        ZPG
        DEX
        BNE        LBL
ZPG     EPZ        $0F


During pass one of the assembly, LISA computes the address of LBL by adding
up all of the program bytes from the beginning of the program to the label.
Unfortunately, when then't yet been defined (in pass one), LISA v3.x assumes
that the label is an
absolute label and treats the LDA as a three-byte instruction.  Later during
pass one, ZPG is defined to be a zero page value.  So during pass two, a
two-byte instruction (rather than a three-byte instruction) is generated
which causes a phase error.  To prevent this from happening, LISA v3.x will
print an error message if you attempt to define a zero page label after it
was encountered in the text.  To solve this little problem, simply move the
EPZ definition to an earlier point in the text or use the FZR pseudo-opcode
to state that the label is a zero page label.  Incidentally,  LISA v2.6
doesn't require a mechanism like this because it is a three-pass assembler.
LISA v2.6 collects all of the zero page labels during pass one and then
processes the remaining text during passes two and three.  LISA v3.x is a
two-pass assembler which is why FZR is required.  The advantage of a two-pass
assembler is that it is significantly faster than a three-pass assembler.

Note that the LCL pseudo-opcode completely undefines the label following it.

If a label is declared as a zero page label (with either EPZ or FZR) and
then that same label appears in the operand field of an LCL pseudo-opcode,
you must declare the new value of the label before it is used if the label is
a zero page label.  Good programming style dictates that local labels defined
via equate statements be declared right after the occurrence of the LCL
directive.  MSG, whose sole operand must be a string, prints a message during
both passes of the assembly.  The IF1 and IF2  directives can be used to
selectively print the message during pass one or two.  The up-arrow (caret)
character has special significance within a MSG string.

"^^" prints a single up-arrow character.
"^R" prints a carriage return.
"^H" homes the cursor and clears the screen.
"^B" beeps the speaker.

Other special characters will be defined in later versions of LISA v3.x.

SBT is used in a fashion identical to TTL.  SBT is used to define a
subtitle.  The single string which follows is stored in LISA's internal
subtitle string variable and it is output at the top of each page immediately
below the major title.  SBT does not cause an automatic page  ejection.
Follow the SBT directive with a PAG directive if you wish a form feed.

The CHN directive is identical to LISA v2.6's ICL directive, except only
valid ANIX filenames are allowed within the string following the CHN
mnemonic.

The ANX directive (for ANIX command) is similar to the LISA v2.6 DCM
command.  It lets you execute an ANIX intrinsic command during assembly.
This command is useful for SAVE'ing binary object code to disk, changing
default disk drives with the "PREFIX" command, etc.  Placing a control-P in
the quotation marks will turn on the ANIX printer device.  Note that unlike
DCM, ANX is active on both passes.  Use the IF1 and IF2 directives to execute
ANX during only one of the passes.

The INP command will prompt you to enter the value of a label during
assembly.  A symbol defined this way is always an absolute label.

Note that the ASC directive which appears in LISA v2.6 is not implemented in
LISA v3.x, use the BYT directive instead.Address Expressions  Address
expressions in LISA v3.x have changed dramatically since LISA v2.6.   In
fact, the major source of file incompatibility centers around address
expressions.  First of all, LISA v3.x evaluates expressions from left to
right.

This is a source of incompatibility between the LISA v2.6 assembler (which
evaluates expressions from right to left) and the LISA v3.x assembler.  For
example, in LISA v2.6 the equate:

LBL         EQU        5-3+1

evaluates to 5-(3+1) returning one.  In LISA v3.x this expression evaluates
to (5-3)+1 returning three.  The exclamation mark is no longer allowed in
front of decimal constants.  Negative decimal constants should be entered as
a minus sign followed by the decimal digits.

The format for single character constants (e.g., after the " " in an
immediate expression) has been changed somewhat.  With LISA v2.6 the
quotation mark is represented using the character sequence """.  In LISA
v3.x, four quotation marks are required (which makes the usage identical to
that for character strings).  Likewise, when you are enclosing character
expressions within apostrophes, the apostrophe character is represented with
four apostrophes, e.g.,

''''.

LISA v3.x supports three unary operators, "-" (negation), "~" (logical
complement), and "@" (relative address).  The "-" operator takes the two's
complement of the value which follows, the "~" inverts the bits of the value
which follows.  The "@" operator subtracts the current location counter value
from the address that follow the "@" (at sign). The unary operators have
precedence over the binary operators.

LISA v3.x supports fourteen binary operators.  They are:

        +        -        *        /        &        |        ^

        =        <        >        %        <=        >=        <>

Note that LISA v2.6 uses " " for not equal and LISA v3.x uses "<>" for not
equal.  Interleaving spaces are not allowed between the two characters in the
"<=", ">=", and "<>" operators (you'll see why in a minute).  The comparison
operators return zero if the comparison does not hold, one if the comparison
is true.  The "%" operator is the modulo (remainder) operator.  It returns
the remainder of the operand to the left of the "%" divided by the operand to
the right.

Like LISA v2.6, LISA v3.x reuses several symbols as operators in address
expressions.  Such multiple use can lead to certain ambiguities.  For
example, consider the expression:

>0<>0

Does this mean >0 <> 0, or does it mean >0 < >0? To eliminate such problems
in these rare situations, simply type ">0 <> 0" for the first form, or ">0 <
>0" for the second form.  Unlike LISA v2.6, LISA v3.x's editor allows you to
enter spaces into the middle of address expressions.  These spaces are used
to resolve conflicts when an ambiguity problems arise.

The BYT, ADR, HBY, and DBY pseudo-opcodes allow the same operands as the
".DA" directive.  ASCII strings (surrounded by quotation marks or
apostrophes) generate a single byte of data for each character in the string.

If an address expression is prefaced with a pound sign (" "), then LISA v3.x
will logically AND the sixteen-bit address expression with $FF and use the
result as the value for the address expression.  For example, the instruction
"ADR $FFEE" is identical to "ADR $EE".  The "/" operator, if it prefaces an
address expression in the operand field of BYT, ADR, HBY,  or DBY, shifts
this address expression to the right eight bits and uses the resultant value.
"ADR /$FFEE" is identical to "ADR $FF".  "BYT /$FFEE" is equal to "BYT $FF"
which is equal to "HBY $FFEE".

Note that "HBY /$nnnn" always produces zero, regardless of the value of
$nnnn.  The " " and "/" operators behave exactly like their LISA v2.6
counterparts when they are used in the operand field of a ".DA" or "CSP"
instruction.Converting LISA v2.6 Files to LISA v3.2 LISA v3.2 uses a
completely different tokenizing scheme than LISA v2.6.  The advantages to the
new scheme include reduced storage requirements and a faster assembly rate.
The disadvantage is that LISA v2.6 files cannot be directly loaded into LISA
v3.2.

To convert a LISA v2.6 (or any older version of LISA) source file to LISA
v3.2, the first thing you should do is assemble your LISA v2.6 source file
and save the object code to disk.

This is a very important step!  Next, write the LISA v2.6 source file to disk
using the LISA v2.6 W)rite command.  At this point, run the ProDOS CONVERT
utility and copy the text and object code files from your DOS 3.3  disk to a
ProDOS disk (if you are still running LISA v1.5 on DOS 3.2, MUFFIN the file
to DOS 3.3 before running the CONVERT utility).  Then boot LISA v3.x and use
the LISA v3.x R)ead command to tokenize the source file.   While the file is
being read into memory, LISA v3.2 will stop whenever it encounters a line it
doesn't like.  This usually occurs when an ENZ, ICL, ASC, or DCM directive is
encountered in the LISA v2.6 source file.  LISA v3.x will also print an error
message and make you retype the line if a decimal constant prefaced with an
exclamation mark or three apostrophes (or quotation marks) are found on the
line.  Simply retype the line without the exclamation mark or add an
additional quote or apostrophe to the line.  In the case of ENZ, simply hit
return.  For ICL, substitute CHN for the ICL and check to make sure the
filename is a valid ANIX filename.  If you encounter an ASC pseudo-opcode,
substitute BYT for ASC and copy the operand  field after the BYT directive.
DCM requires the most modification since ANIX commands and DOS 3.3 commands
are somewhat different.  Consult the ANIX manual for more details concerning
valid ANIX commands.

Another place you may encounter difficulty is with the older LISA v1.x style
immediate character and hexadecimal constants.  The earliest versions of LISA
allowed an immediate operand to consist of an apostrophe or quotation mark
followed by a single character, or a hexadecimal value that began with a
numeric digit.  E.g.:

LDA 'C -- Same as LDA 'C'
LDA "C -- Same as LDA "C"
LDA 01 -- Same as LDA 01

As promised in the LISA v2.6 manual, these forms of the immediate operand
are no longer supported.  In the case of the first two instructions, the LISA
v3.2 editor will print an error message when you attempt to read the
instruction into the editor.  The third case will produce an error only if
the hexadecimal value following the instruction contains a hexadecimal digit
in the range $A...$F.  If the value following the instruction is composed
entirely of decimal digits, LISA v3.2 will think that you wish to access the
zero page memory location specified by this decimal address.  The easiest way
to catch this type of error is to compare the object code produced by LISA
v3.2 against the object code produced by LISA v2.6 (or earlier), see the next
paragraph for details.

After you've R)ead the entire file into memory, save the file to disk with
the LISA SA)ve command.  Note the size reduction over the LISA v2.6 version!

After saving the source file to disk, assemble the file and leave the object
code in memory.  Now load the object code saved from the LISA v2.6 assembly
at a different location and compare the two pieces of object code using the
monitor Verify command.  Note any locations which are different between the
two assemblies and compare the code emitted by LISA v3.x to LISA v2.6.  If
there are some differences which aren't easily explained, chances are you've
encountered an address expression which returns a different value in LISA
v3.x than in LISA v2.6.  Go back to your source listing and check the
instructions which generated the bad code.  Check both the actual address
expression value and the definitions of any labels used in the expression.
If it doesn't make sense why the bad code was generated, call Lazerware at
(714) 735-1041 to report the problem.

CONVERTING LISA V3.1 FILES TO LISA V3.2

To allow for the additional addressing modes provided by the 65C802 chip, some
internal tokenization formats had to be changed between LISA v3.1 and LISA
v3.2.

If you have some  files in a 3.1 format that you would like to convert to the
3.2 form, simply W)rite the 3.1 file to disk and then R(ead the textfile back
into LISA v3.2.  Other than the tokenizing scheme, LISA v3.1 files are
absolutely compatible with LISA v3.2.

IF YOU FIND A BUG IN LISA V3.2

Actually not "IF", when you find a bug in LISA v3.2 we would appreciate
it if you would tell us about it.  But please, make sure it really is a bug
before calling us.  Also, try to locate the exact nature of the problem.  An
error report of the form "the system just hangs up" is of no value to us.

Find the exact instruction where the assembler is misbehaving (if during
assembly) or try to locate the exact sequence of events which create a
problem in the editor.  The more information you can supply the faster we can
fix the problem.

The best form of a bug report is to send us a copy of your LISA v3.x disk
with the source file containing the problem and a description of where the
problem occurs (naturally, all source files will be handled on a strictly
confidential basis and will be destroyed once the problem is isolated).

The next best solution is to send us a printout of the source file where the
problem occurred.  If either of these cases are impractical, a written
description describing the problem and where it occurs is the next best
thing.  A phone call is the least desirable alternative (although you may
want to call in to see if the bug has already been discovered).

All correspondence should be sent to:

        Lazerware
        2271 Indian Horse Dr.
        Norco, Ca.  91760

All phone inquiries:

        (714) 735-1041 to leave a message.


OTHER LISA V3.2 FEATURES

In additional to other tokenization features, LISA v3.2 tokenizes the symbols
at edit time and maintains an edit time symbol table.  You are limited to 512
symbols for any single source file.  If you get a "Too many symbols" error,
SA)ve the source file to disk as a LISA v3.x file, W)rite the file to disk as
a text file (keeping in mind the 122 sector limitation of ANIX v1.2), clear
the source file with the LISA N)ew command, and then R)ead the source file
back into memory retokenizing it.  This will almost always  solve the problem
since LISA v3.2 does not delete symbols from the edit time symbol table which
are no longer present in the source file.  The W)riting and R)eading operation
strips all unused symbols from the edit time symbol table.  A big source file
(with about 3,000 lines) typically has between 300 and 400 symbols.

The DS (Dump Symbols) program on the disk can be used to dump the symbol
table after an assembly.  To use this program, type:

<control-D>LOAD DS<return>

after the LISA v3.2 "!" prompt, and then type

"<control-D>RUN 800"

If you wish to send the output to a printer in slot one, typing control-P at
the beginning of a line turns on the printer.  Under ANIX v2.1 you can direct
the output to any slot, or even to a disk file using RUN commands of the form

"<control-D>RUN 800 >.Sn" (to slot 'n', you should avoid this form)
"<control-D>RUN 800 >.P"  (to the printer)
"<control-D>RUN 800 >.C"  (to the communications port)
"<control-D>RUN 800 >FILENAME"

assuming, of course, that you've installed the appropriate ANIX device driver.

THE ADVANCED LISA EDITOR (ALE)

Without question, the biggest addition LISA v3.2 offers is the Advanced LISA
Editor (ALE for short).  The Advanced LISA Editor program brings a full funct-
ion editor to the LISA assembler environment.  Additional commands like find,
find and replace, move, copy, improved listing facilities, intraline editing,
and a help command give the LISA user all of the editing features (and more!)
found in the other assembly language packages.  On top of the new editing
features, ALE also provides a built in hexadecimal calculator, a ASCII
character set reference chart, two ProDOS equate reference charts, an ANIX
v2.1 equate reference chart, and a CHARIO equate reference chart (CHARIO is
an ANIX v2.1 subroutine).  The new editor package will dramatically reduce the
amount of time required to work on an existing program.

First the bad news.  You don't get all of this editing power for nothing.
ALE is a separate program from the LISA assembler, hence you will not be able
to quickly perform an assembly immediately after an editing session.

Another piece of bad news: a version of ALE is not available for LISA v3.2
users that runs on a 64K system.

You will need a minimum of 80K in your Apple ][ system (or 128K in your
Apple //e or Apple //c system).  If you are running on an 80K Apple ][ or
Apple ][ Plus system, you will need to reload the assembler before performing
the assembly; this means you will lose several seconds when switching between
the editor and assembler (you've got to save the current workfile, enter ANIX,
load the LISA assembler, load your workfile, and then you can assemble your
sourcefile).

Now for some good news.  If you've got a 96K or larger Apple ][ /][ Plus or
a 128K Apple //e-//c, both LISA and the ALE program may reside in memory at
the same time and can be swapped in less than four seconds (less than two
seconds on an Apple //e-//c).  The disadvantage, of course, is that your
Apple requires a bit more memory.  On a 128K Apple //e or Apple //c this
won't affect you since the minimum amount of memory LISA will work with is
128K, but on the older Apple ][ Plus systems you will need three language
cards, a 32K card and a 16K card, or a 64K (or larger) memory board.

Lazerware recommends a 64K or 128K memory board since the additional memory
in Apples so equipped can be used for other purposes besides running LISA
and ALE (like disk emulators, Visicalc* expanders, etc.).  Keep in mind, the
extra memory isn't necessary for running ALE, it just makes ALE's execution a
lot more convenient.  This document will make no distinction between the
combined ALE/LISA and the separate ALE -LISA programs.  The usage of the
individual programs is identical except for the mechanism used to swap
between the two programs.  The following script should be followed when
switching between LISA and ALE on an 80K Apple ][ or Apple ][ Plus system:

From LISA to ALE:

!SAVE <filename>         -- Save current workfile to disk.
!SYS                     -- Quit LISA and enter ANIX v2.0.
=ALE                     -- Execute the ALE program.
:LOAD <filename>         -- Load workfile into memory.

From ALE to LISA:

:SAVE <filename>         -- Save current workfile to disk.
:SYS                     -- Quit ALE and enter ANIX v2.0.
=LISA                    -- Execute the LISA assembler program.
!LOAD <filename>         -- Load workfile into memory.

On a 96K (or larger) Apple system, this process is tremendously simplified.
When running the SETUP.LISA program, you will be asked if you have a 96K (or
larger) Apple system.  If you answer yes (by specifying your particular memory
configuration) then SETUP.LISA will create  a LISA program which automatically
loads the combined LISA/ALE program into memory.  When running the combined
version, you can switch between the LISA assembler and the ALE editor by
simply type "U" followed by return.  E.g.:

From LISA to ALE:

!U     H               -- Switch to ALE (takes a few seconds)

From ALE to LISA:

:U                       -- Switch to LISA (takes a few seconds)



! -- THE PROMPT CHARACTER

The prompt character can be used to determine which program you're currently
operating in.  LISA uses an exclamation mark for the prompt character (a
carry over from the mini-assembler found in Integer BASIC for those of you who
are curious) and the ALE program uses a colon for its prompt character.  If
you ever find yourself in the wrong program, simply press "U" to switch
between the two.

THE NEW ALE COMMANDS

The Advanced LISA Editor program is an extended version of the standard LISA
editor.  ALE was created by removing the assembler from LISA v3.2 and using
the space freed to extended the editor.  Since ALE is an extension of the LISA
editor, all of the editor commands you've been using in LISA are present in
ALE as well.  So you're not going to have to learn a whole new set of commands
just the new commands that ALE provides.  All of the standard LISA v3.2 edit-
ng commands are supported in ALE.

Probably the first new command worthy of discussion is help.  Whenever you
are presented with the ALE colon prompt, you can get a list of the commands
by pressing a question mark followed by return.  So if you forget one of the
editing commands, simply press "?" and ALE will list all of the commands.

If you're already missing LISA v2.6's FIND command in LISA v3.2, fret not, a
much better version is supplied in the ALE program.  The FIND command in LISA
v2.6 searched only for labels in the source file; the ALE command will search
for almost any string within a LISA v3.2 source file.  The syntax for the
FIND command is:

F{ind} <string>

The curly braces surround optional characters, i.e., "F" followed by a space
works just fine.  Note that "FR" is reserved for FIND & REPLACE, so the
second character of the FIND command must not be an "R" unless you want to
execute the FIND & REPLACE command.

The FIND command builds the string by locating the first non-blank character
after the FIND command.  The string consists of every character from this
non-blank character to the end of the line.  Once you press return, ALE will
search for each occurrence of the specified string and the  line containing
that string will be listed.  Since there may be multiple occurrences of the
string on a single line, ALE always inverts the string when the line is
displayed on the screen.  So if the same line is listed twice, it's due to
multiple occurrences on the same line.

If there are more than 22 occurrences of the string within your source file,
you can temporarily halt the FIND command by pressing the space bar.  Once
you've stopped the listing by pressing the space bar, pressing control-C will
abort the FIND command, pressing return will list the next  occurrence of the
string in the file, and pressing any other key will resume the fast search.

The ALE FIND command converts all lower case characters to uppercase before
performing the search.  Therefore, the case of the search string is
irrelevant.  To speed up the (already slow) searching process, a programming
trick was used to match upper and lower case characters.  There are two
unfortunate side effects of this programming trick: first, all characters in
the range $C0...$DF will match all characters in the range $E0...$FF; second,
all characters in the range $80...$9F will match all of the characters in the
range $A0...$BF.  This means that, in addition to converting lower case to
uppercase, certain special characters will match other characters.  For
example, the grave accent ("`") will match the at sign ("@").  Likewise, the
numeric and lower valued special characters will match the control characters.
Since control characters almost never appear within an assembly language
source file, this second problem will rarely cause you any trouble.

Another command present in ALE, one which has been long requested by
faithful LISA users, is a FIND & REPLACE command.  The syntax for this
command is FR Gsearch stringH ^ Greplacement stringH The up-arrow character
(the little caret symbol above the "6" on Apple //e and Apple //c systems,
above the "N" on Apple ][ and Apple ][ Plus systems) is used to separate the
search string with the string it is to be replaced with.  The following
command replaces each occurrence of "LBL1" with "LABEL1":

FR LBL1^LABEL1

Whenever the FIND & REPLACE command locates a line containing the search
string, it lists the line to the screen and asks you if you want to replace
this occurrence with the replacement string.  When so prompted you may  enter
"Q" or "q" for quit, "Y" or "y" for YES, or "N" or "n" for NO.  All other
input will be ignored.  If you answer YES, the FIND & REPLACE command will
substitute the replacement string for the source string and attempt to
retokenize the new line.  If an error occurs during tokenization, you will
have to retype the entire line (hopefully in a corrected form) into ALE.  If
you select "N", then the FIND & REPLACE command ignores the current line and
searches for the next occurrence of the search string.  If you select "Q",
the FIND & REPLACE command will abort processing and return to the ALE
command mode.  The ALE program also provides COPY and move (TRANSFER)
commands.  These useful commands let you duplicate a block of statements
within the file or move a block of statements elsewhere in the file.  The
syntax for these commands is:

CO{py} <start>, <end>, <dest>
TR{ansfer} <start>, <end>, <dest>

The three parameters following these commands are all line numbers within
the source file.

The <start> line number is the first line of the source block which you want
to copy or move.  The <end> line number, which must be greater than or equal
to the <start> line number, is the line number of the last line of the line
of the block to be copied or moved.  If <end> is greater than the last line
in the file, it will default to the last line in the file.

The <dest> parameter is the destination line number.  This value must be
greater than <end> or less than <start> or ALE will give you an error.

The COPY command will duplicate lines <start>...<end> at line number <dest>.

The TRANSFER command also performs this duplication, but then deletes the
original lines from the file.

Three new versions of the list command have been added to ALE's command
repertoire.  Pressing a comma (",") followed by return lists the next 15
lines in the file.  Pressing a period lists the fifteen lines around the
current line.  Pressing a hyphen ("-") lists the prior twenty lines.  These
list commands simulate the page up, page down, and rewrite page commands
found in screen oriented editors.

The current line is defined by the last LIST, DELETE, or INSERT command
executed in ALE.  The last line listed by the last LIST command (including
",", ".", and "-") becomes the new current line.  If the last command was a
DELETE command, the line after the last (or only) line deleted becomes the
new current line.  If the last command was an INSERT (or MODIFY) command,
then the current line is the first line after the text you've inserted.  The
period command is really useful for cleaning up the display, especially after
you've performed several screen editing commands.  The comma and hyphen list
commands simulate page down and page up commands in a screen oriented editor.
These commands are great for leisurely searching through a source file.

In addition to the new editor commands, ALE also supports four built in
intraline editing commands.  These commands, which are available while in the
insert mode, simulate the up and down arrow key functions in a screen
oriented editor; they allow you to skip over or edit lines adjacent to the
current input line.  These commands are invoked by pressing control-A,
control-B, control-C, or control-W as the first character of an input line.

The control-A and control-B commands are complementary.

The control-A command takes the previous line and moves it down making it
the next line in the file.  For example, if you accidentally entered the
insert mode one line below the desired line, you could use control-A to move
the insertion point in front of the previous line.

The control-B operation performs the converse operation to the control-A
command; it swaps the current line with the next line in the source file.
Control-B is useful for several things.  It lets you skip over any number
of lines in the source file allowing you to selectively insert lines within
the source file without having to exit and reenter the insert mode.  It also
allows you to adjust the insertion point if you accidentally typed the wrong
line number after the insert command.

The control-C and control-W commands are also complementary. Rather than swap
the next or previous line with the current line, the control-C and control-W
commands simply list the next or previous line and then delete it.

Control-C lists and deletes the next line; control-W lists and deletes the
previous line.

The control-W command turns out to be the most useful of the intraline
editing commands.  If you make a mistake (one which is syntactically correct)
while entering a line of text at the keyboard and you've already pressed
return, you can reedit this invalid line by pressing control-W as the first
character of the next line.

The control-C command lists and then deletes the following line in the file.
The control-C command is useful when you want to insert a few lines and then
modify a couple of lines that follow the lines you've inserted.