
eX version 0.4b User's Manual                         File eXMan14.txt
(C) Copyright 1995, 1996 William E. Wilgus III.   All rights reserved.


Non-operator Characters / Character Sequences


The number(s) in parenthesis following the character(s) being
described is (are) the ASCII code(s) of the character(s).
 
Horizontal Tab (9)
     `Whitespace'

Line Feed (10)
     `Whitespace'

Vertical Tab (11)
     `Whitespace'

Form Feed (12)
     `Whitespace'

Carriage Return (13)
     `Whitespace'

Space (32)
     `Whitespace'

! (33)
     Factorial function. 
                              ! #

" (34)
     String literal delimiter. (See also `.) 

# (35)
     Numeric data class (eev) filter. 
     States no string eev is available, but doesn't force a numeric 
     eev to exist.  Must be surrounded by whitespace and is otherwise 
     inert.  

# (35)
     Binary operator numeric data class suffix. 
     Prohibits an operator from performing any operation other than   
     the numeric by numeric.  However, if no numeric right-hand
     operand is provided to the operator, no operation is performed. 
     The suffix does not destroy any data class eevs.

# (35)
     Function numeric data class suffix. 
     Certain functions allow the use of this character as a suffix to 
     force the return of numeric data.  The use of a function suffix  
     is ignored if the function does not recognize suffixes.

$ (36)
     String data class filter. 
     States that no numeric eev is available, but doesn't force a 
     string eev to exist.  Must be surrounded by whitespace and is 
     otherwise inert.

$ (36)
     Binary operator string data class suffix. 
     If a string eev is provided to the operator, the string by string
     operation is performed.  If a string eev is not provided to the 
     operator but a numeric eev is, the string by numeric operation is
     performed.  Numeric by numeric operations are precluded.  The
     suffix does not destroy any data class eevs.

$ (36)
     Function string data class suffix. 
     Certain functions allow the use of this character as a suffix to
     force the return of string data.  The use of a function suffix is
     ignored if the function does not recognize suffixes.  

$ (36)
     String variable prefix.  

% (37)
     Operated address token, one preceding each operator or operator 
     group in the address: 1 % + 2 % * + 3.  

& (38)
     Radix operator. 
     The Radix designator must immediately follow.  Returns the
     decimal numeric value of the argument, which is a string 
     containing the ASCII representation of the number in the base
     designated.  e.g., `&h "ff"' returns 15.  Literals must be enclosed 
     in quotes (") or reverse quotes (`) `&h "ff"'.  See the section 
     `Radix Operators' in the chapter `Operators'. 

& (38)
     Radix function. 
     The Radix function designator must immediately follow.
     Literal arguments must not be enclosed in quotes.  See the
     section `Radix Functions' in the chapter
     `Data Type Cast & Radix Functions'. 

& (38)
     Logical operator `AND'  

&# (38, 35)
     Numeric logical operator `AND'.  

&$ (38, 36)
     String logical operator `AND'.  

' (39)
     Accumulator plane `push'. 
     Pushes the current plane (must be preceded by whitespace.)  
     Multiple pushes are allowed without intervening whitespace.  

' (39)
     Aggregation accumulator `push'. 
     Pushes the aggregation's accumulator(s) on an internal stack for
     later recall.  In the absence of a data type suffix, both
     accumualtors (numeric and string) are pushed.  A data class
     suffix (# or $) can be used to limit the push to the accumualtor
     of that type.  

' (39)
     Aggregation accumulator `pop'. 
     In the absence of a data type suffix, both accumualtors (numeric
     and string) are popped.  A data class suffix (# or $) can be used
     to limit the push to the accumualtor of that type.  

( (40)
     Beginning (parenthesized) function argument delimiter.  

( (40)
     Beginning `standard' aggregation delimiter.  
     Unless an accumulator hold command is given, it implies an
     addition operation to load the accumulators.  See also the
     accumulator push and hold commands. 

) (41)
     Ending (parenthesized) function argument delimiter.  

) (41)
     Ending aggregation delimiter.  
     See also the accumulator pop commands. 

, (44)
     Parenthesized function argument separator.  
     NOTE that it also resets the accumulators for the plane, level
     that it appears in to 0.0 and "".

, (44)
     List element separator. 
     If the list is for show, print, or write, a carriage return is
     issued after the list element it delimits.

. (46)
     Single precision floating-point variable prefix.  

. (46)
     Numeric decimal point.

.. (46, 46)
     Double precision floating-point variable prefix.

.\ (46, 92)
     Current directory file path element.

..\ (46, 46, 92)
     Parent directory file path element.

: (58)
     eX file specification prefix. 
     Used as a data entity prefix when addressing a file, not used
     when referencing a file.

:# (58, 35)
     File number prefix.  

:= (58, 61)
     Assignment operator.

:> (58, 62)
     Label token, which must be followed by either an un-delimited
     name or by whitespace followed by an indirectly specified name or
     de-limited literal name.  A label is used to identify a portion
     of a macro for intra-macro program directives and is otherwise
     inert.  Un-like a macro, a label has no terminus other than that
     of the macro itself.

; (59)
     Carriage return supressor. 
     As a suffix to show, print, ? (keyboard input), write, and 
     implied sequential file output operations, prevents issuance of
     carriage return after input or output of the (last) item (in the
     argument list).  (Lists are not available with ?.)

; (59)
     List element seperator. 
     Used to seperate items in an argument list.  Carriage returns are
     not issued between list items.  For show and print, if the
     semi-colon is not followed by whitespace, the character(s) that
     follow is a (are) literal(s) that is (are) to be output.  The
     underscore is used to print a space. Any such literals must
     ultimately be followed by whitespace.

; (59)
     Aggregation accumulator hold. 
     In a loop structure, additionally holds the loop count and truth,
     and is executed only once---on entry to the loop.  In a parens
     aggregation, precludes the left paren's implied addition
     operation that `loads' the accumulator(s).  In a parens
     aggregation, a data class suffix (# or $) may be used to limit 
     the hold the the accumulator of the suffix's data class.  In a
     loop aggregation, any or all of the following tokens may be used 
     to specify which aggregation entities are held:
           #  numeric accumulator
           $  string accumulator
           ?  loop truth (look for this to disappear)
           %  loop count
     In the absence of all of the above tokens, all of the above loop
     entities are held. 

? (63)
     This token represents the loop truth in a loop hold command. 

? (63)
     Keyboard input.  
     The keyboard input syntax options are 

     ?<<;>> <<"Prompt">> DataEntity
          assigns the input value to DataEntity, taking its cue for 
          which data class to input from it. 

     DataEntity := ?<<;>> <<"Prompt">>
          supplies the value for the assignment, taking its cue for
          which data class to input from DataEntity. 

     ?<<;>> <<"Prompt">> $
          inputs a string value (and is equivalent to a string
          literal)

     ?<<;>> <<"Prompt">> #
          inputs a numeric value (and is equivalent to a numeric
          literal) 

     The editing facilities are

     move cursor 
                character right      right cursor key or ctrl \
                          left       left cursor key  or ctrl ]
                word      right      ctrl right cursor key or ctrl F
                          left       ctrl left cursor key  or ctrl B
                beginning of input   Home or ctrl K
                end of input         End or ctrl N
                tab right            Tab or ctrl I
     delete      
                char left/move left  Backspace or ctrl H
                                     (if at beginning of input, 
                                          deletes character at cursor
                character at cursor  Del
                to end of data       ctrl End or ctrl E
                all data/abort input Esc or ctrl U
     toggle      
                insert mode          Ins or ctrl R
                function key display ctrl T
     terminate   
                input (accept data)  Return or ctrl M
                program              Break or ctrl C


?; (63, 59)
     Keyboard input with carriage return supression suffix.  
     See also ?. 

@ (64)
     Accumulator address for the numeric and string accumulators of
     the current plane, level.

@(plane#, level#) (64)
     Accumulator address for the numeric and string accumulators of
     the specified plane, level. 

@# (64, 35)
     Accumulator address for the numeric accumulator of the current 
     plane, level.

@#(plane#, level#) (64, 35)
     Accumulator address for the numeric accumulator of the specified 
     plane, level. 

@$ (64, 36)
     Accumulator address for the string accumulator of the current 
     plane, level.

@$(plane#, level#) (64, 36)
     Accumulator address for the string accumulator of the specified 
     plane, level.

[ (91)
     Beginning loop/aggregation delimiter.  
     See also accumulator push commands and hold commands.  If both
     commands are given, the push must appear first and no whitespace 
     may intervene. 

] (93)
     Ending loop/aggregation delimiter.  
     See also the available accumulator pop commands.

_ (95)
     Signed short integer variable prefix. 

__ (95, 95)
     Signed long integer variable prefix. 

{ (123)
     Beginning conditional test structure delimiter.  

| (124)
     Change  plane token. 

|' (124, 39)
     Change plane with plane pop. 
     Multiple pops are allowed: |''''.  

} (125)
     Ending test delimiter.

~ (126)
     Else token (tilde). 

~{ (126, 123)
     Case token, a `construction' of an else token followed 
     immediately followed by a test. 

