home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
OL.LZH
/
DATA.LZH
/
IHELP.DAT
< prev
next >
Wrap
Text File
|
1991-07-13
|
30KB
|
1,009 lines
Icon Programming Language Version 8 Help Summaries
Help summaries are available for each of the Icon executable
programs (icont, iconx), and for many aspects of the Icon
language itself.
To see the help summaries, enter one of the following commands:
ihelp icont # Icon translator & linker
ihelp iconx # Icon interpreter
ihelp expressions # summary of expressions & precedence
ihelp functions # summary of functions
ihelp operations # summary of operations
ihelp keywords # list of keywords
ihelp datatypes # list of Icon datatypes
ihelp reserved # list of reserved words
ihelp escapes # list of string escape sequences
ihelp abbreviations # abbreviations used in help files
ihelp <function name> # information on specific function
ihelp about # bibliography and credits for help file
-
abs(N) : N # compute absolute value
Produces the absolute value of N.
-
acos(r1) : r2 # compute arc cosine
Produces the arc cosine of r1 in the range of 0 to pi for r1 in the
range of -1 to 1.
-
any(c,s,i1,i2) : i3 # locate initial character
Succeeds and produces i1 + 1 if s[i1] is in c and i2 > i1, but fails
otherwise.
Defaults:
s &subject
i1 &pos if s defaulted, otherwise 1
i2 0
-
args(p) : i # get number of procedure arguments
Produces the number of arguments for procedure p. For built-in
procedures with a variable number of arguments, the value produced is
-1. For declared procedures with a variable number of arguments, the
value returned is the nagative of the number of formal prameters.
-
bal(c1,c2,c3,s,i1,i2) : i3,i4,...,in # locate balanced characters
Generates the sequence of integer positions in s preceding a character
of c1 in s[i1:i2] that is balanced with respect to the characters of c2
and c3, but fails if there is no such position.
Defaults:
c1 &cset
c2 '('
c3 ')'
s &subject
i1 &pos if s defaulted, otherwise 1
i2 0
-
callout(x,x1,x2,...,xn) : xm # call external function
Calls the external function specified by x with arguments x1, x2, ...,
xn. The mechanism for locating the function specified by x is system
dependent.
-
center(s1,i,s2) : s3 # position string at center
Produces a string of size i in which s1 is centered, with s2 used for
padding at left and right as necessary.
Defaults:
i 1
s2 " " (blank)
-
char(i) : s # produce character
Produces a string of length 1 consisting of the character whose
internal representation is i.
-
close(f) : f # close file
Produces f after closing it unless f was opened with the pipe ("p")
option, in which case the integer exit status of the command is
returned.
-
collect(i1,i2) : n # perform garbage collection
Causes a garbage collectionin region i1, requesting i2 bytes of space
in that region. It fails if the requested space is not available. The
regions are identified as follows:
1 Static region
2 String region
3 Block region
If i1 is 0, a collection is done, but no region is identified and i2
has no effect. The value of i2 is ignored for the static region.
Defaults:
i1 0
i2 0
-
copy(x1) : x2 # copy value
Produces a copy of x1 if x1 is a structure; otherwise it produces x1.
-
cos(r1) : r2 # compute cosine
Produces the cosine of r1 in radians.
-
cset(x) # convert to cset
Produces a cset resulting from converting x, but fails if the
conversion is not possible.
-
delete(X,y) : X # delete element
If X is a set, deletes x from X. If X is a table, deletes the element
for key x from X. Produces X.
-
detab(s1,i1,i2,...,in) : s2 # remove tabs
Produces a string based on s1 in which each tab character is replaced
by one or more blanks. Tab stops are at i1, i2, ..., in, with
additional stops obtained by repeating the last interval.
Default:
i1 9
-
display(i,f) : n # display variables
Writes the image of the current co-expression and the values of the
local variables in the current procedure call. If i > 0, the local
variables in the i preceding procedure calls are displayed as well.
After all local variables are displayed, the values of global variables
are displayed. Output is written to f.
Defaults:
i &level
f &errout
-
dtor(r1) : r2 # convert degrees to radians
Produces the radian equivalent of r1 given in degrees.
-
entab(s1,i1,i2,...,in) : s2 # insert tabs
Produces a string based on s1 in which runs of blanks are replaced by
tabs. Tab stops are at i1, i2, ..., in, with additional stops obtained
by repeating the last interval.
Default:
i1 9
-
errorclear() : n # clear error indication
Clears the indications of the last error.
-
exit(i) # exit program
Terminates the program with exit status i.
Default:
i normal exit (system dependent)
-
exp(r1) : r2 # compute exponential
Produces e raised to the power r1.
-
find(s1,s2,i1,i2) : i3,i4,...,in # find string
Generates the sequence of integer positions in s2 at which s1 occurs as
a substring in s2[i1:i2], but fails if there is no such position.
Defaults:
s2 &subject
i1 &pos if s2 defaulted, otherwise 1
i2 0
-
get(L) : x # get value from list
Produces the leftmost element of L and removes it from L, but fails if
L is empty; synonym for pop(L).
-
getenv(s1) : s2 # get value of environment variable
Produces the value of environment variable s1, but fails if the
variable is not set or environment variables are not supported.
-
iand(i1,i2) : i3 # compute bit-wise "and"
Produces the bitwise "and" of i1 and i2.
-
icom(i1) : i2 # compute bit-wise complement
Produces the bitwise complement (1's complement) of i1.
-
image(x) : s # produce string image
Produces a string image of x.
-
insert(X,x1,x2) : X # insert element
If X is a table, inserts the key x1 with value x2 into X. If X is a
set, inserts x1 into X. Produces X.
Default:
x2 &null
-
integer(x) : i # convert to integer
Produces the integer resulting from converting x, but fails if the
conversion is not possible.
-
ior(i1,i2) : i3 # compute bit-wise inclusive "or"
Produces the bitwise inclusive "or" of i1 and i2
-
ishift(i1,i2) : i3 # shift bits
Produces the result of shifting the bits in i1 by i2 positions.
Positive values of i2 shift to the left, negative to the right.
Vacated bit positions are zero-filled.
-
ixor(i1,i2) : i3 # compute bit-wise exclusive "or"
Produces the bitwise exclusive "or" of i1 and i2.
-
key(T) : x1,x2,...,xn # generate keys from table
Generates the keys in table T.
-
left(s1,i,s2) : s3 # position string at left
Produces a string of size i in which s1 is positioned at the left, with
s2 used for padding on the right as necessary.
Defaults:
i 1
s2 " " (blank)
-
list(i,x) : L # create list
Produces a list of size i in which each value is x.
Defaults:
i 0
x &null
-
log(r1,r2) : r3 # compute logarithm
Produces the logarithm of r1 to the base r2.
Default:
r2 e
-
many(c,s,i1,i2) : i3 # locate many characters
Succeeds and produces the position in s after the longest initial sequence
of characters in c in s[i1:i2]. It fails if s[i1] is not in c.
Defaults:
s &subject
i1 &pos if s defaulted, otherwise 1
i2 0
-
map(s1,s2,s3) : s4 # map characters
Produces a string of size *s1 obtained by mapping characters of s1 that
occur in s2 into corresponding characters in s3.
Defaults:
s2 string(&ucase)
s3 string(&lcase)
-
match(s1,s2,i1,i2) : i3 # match initial string
Produces i1 + *s1 if s1 == s2[i1+:*s1], but fails otherwise.
Defaults:
s2 &subject
i1 &pos if s2 defaulted, otherwise 1
i2 0
-
member(X,x) : x # test for membership
If X is a set, succeeds if x is a member of X, but fails otherwise. If
X is a table, succeeds if x is a key of an element in X, but fails
otherwise. Produces x if it succeeds.
-
mmout(x) : n # write text to allocation history
Writes s to the allocation history file. s is given no
interpretation.
-
mmpause(s) : n # write pause to allocation history
Writes s to the allocation history file as a pause point with
identification s.
Default:
s "programmed pause"
-
mmshow(x,s) : n # redraw in allocation history
Specifies redrawing of x in the allocation history file. The color is
defined by s as follows:
"b" black
"g" gray
"w" white
"h" highlight; blinking black and white if possible
"r" normal color
If x is not in an allocated region, has no effect.
Default:
s "r"
-
move(i) : s # move scanning position
Produces &subject[&pos:&pos + i] and assigns i + &pos to &pos, but
fails if i is out of range; reverses assignment to &pos if resumed.
-
name(x) : s # produce name
Produces the name of the variable x. If x is an identifier or a
keyword that is a variable, the name of the identifier or keyword is
produced. If x is a record field reference, the record name and field
name are produced with a separating period. If x is a string, the name
of the string and the subscript range are shown. If x is a subscripted
list or table, the type name followed by the subscripting expression is
produced.
-
numeric(x) : N # convert to numeric
Produces an integer or real number resulting from converting x, but
fails if the conversion is not possible.
-
open(s1,s2) : f # open file
Produces a file resulting from opening s1 according to options in s2,
but fails if the file cannot be opened. The options are:
"r" open for reading
"w" open for writing
"a" open for writing in append mode
"b" open for reading and writing
"c" create
"t" tranlsate line termination sequences to linefeeds
"p" pipe to/from a command -- UNIX
The default mode is to translate line termination sequences to
linefeeds on input and conversely on output. The untranlsated mode
should be used when reading and writing binary files.
Default:
s2 "rt"
-
ord(s) : i # produce ordinal
Produces an integer (ordinal) between 0 and 255 that is the internal
representation of the single character in s.
-
pop(L) : x # pop from list
Produces the leftmost element of L and removes it from L, but fails if
L is empty; synonym for get(L).
-
pos(i1) : i2 # test scanning position
Produces &pos if &pos = i1, but fails otherwise.
-
proc(x,i) : p # convert to procedure
Produces a procedure corresponding to the value of x, but fails if x
does not correspond to a procedure. If x is the string name of an
operator, i specifies the number of arguments: 1 for unary (prefix), 2
for binary (infix), and 3 for ternary.
Default:
i 1
-
pull(L) : x # pull from list
Produces the rightmost element of L and removes it from L, but fails if
L is empty.
-
push(L,x) : L # push onto list
Adds x to the left end of L and produces L.
-
put(L,x) : L # put onto list
Adds x to the right end of L and produces L.
-
read(f) : s # read line
Produces the next line from f, but fails on end of file.
Default:
f &input
-
reads(f,i) : s # read string
Produces a string consisting of the next i characters from f, or the
remaining characters of f if fewer remain, but fails on an end of
file. In reads(), unlike read(), line termination sequences have no
special significance. reads() should be used for reading binary data.
Defaults:
f &input
i 1
-
real(x) : r # convert to real
Produces a real number resulting from type conversion of x, but fails
if the conversion is not possible.
-
remove(s) : n # remove file
Removes (deletes) the file named s, but fails if s cannot be removed.
-
rename(s1,s2) : n # rename file
Renames the file named s1 to be s2, but fails if the renaming cannot be
done.
-
repl(s1,i) : s2 # replicate string
Produces a string consisting of i concatenations of s1.
-
reverse(s1) : s2 # reverse string
Produces a string consisting of the reversal of s.
-
right(s1,i,s2) : s3 # position string at right
Produces a string of size i in which s1 is positioned at the right, with
s2 used for padding on the left as necessary.
Defaults:
i 1
s2 " " (blank)
-
rtod(r1) : r2 # convert radians to degrees
Produces the degree equivalent of r1 given in radians.
-
runerr(i,x) # terminate with run-time error
Terminates program execution with error i and offending value x.
Default:
x no offending value
-
save(s) : i # save executable image
Saves an executable image of the current running program in the file
named s and produces the size of the file, but fails if the file cannot
be created.
-
seek(f,i) : f # seek to position in file
Seeks to position i in f, but fails if the seek cannot be performed.
The first byte in the file is at position 1. seek(f,0) seeks to the
end of file f.
-
seq(i1,i2) : i3,i4,... # generate sequence of integers
Generates an endless sequence of integers starting at i1 with
increments of i2.
Defaults:
i1 1
i2 1
-
set(L) : S # create set
Produces a set whose members are the distinct values in the list L.
Default:
L []
-
sin(r1) : r2 # compute sine
Produces the sine of r1 given in radians.
-
sort(X,i) : L # sort structure
Produces a list containing values from X. If X is a list or a set,
sort(X,i) produces the values of X in sorted order. If X is a table,
sort(X,i)produces a list obtained by sorting the elements of X,
depending on the value of i. For Produces a list according to i:
i = (1 | 2) Produces a list of two-element lists of key/value pairs
from X; ordered by keys for i = 1, by values for i =
2.
i = (3 | 4) Produces a list of size 2 * *X with each consecutive
pair of elements consisting of a key and a value from
X; ordered by keys for i = 3, by values for i = 4.
Default:
i 1
-
sqrt(r1) : r2 # compute square root
Produces the square root of r1.
-
stop(x1,x2,...,xn) # stop execution
Terminates program execution with an error status after writing strings
x1,x2,...,xn. If xi is a file, subsequent output is to xi. Initial
output is to standard error output.
Default:
xi "" (empty string)
-
string(x) : s # convert to string
Produces a string resulting from converting x, but fails if the
conversion is not possible.
-
system(s) : i # call system function
Calls the C library function "system" to execute s and produces the
resulting integer exit status.
-
tab(i) : s # set scanning position
Produces &subject[&pos:i] and assigns i to &pos, but fails if i is out
of range. It reverses assignment to &pos if resumed.
-
table(x) : T # create table
Produces a table with a default value x.
Default:
x &null
-
tan(r1) : r2 # compute tangent
Produces the tangent of r1 given in radians.
-
trim(s1,c) : s2 # trim string
Produces a string consisting of the characters of s1 up to the trailing
characters contained in c.
Default:
c ' ' (blank)
-
type(x) : s # produce type name
Produces a string corresponding to the type of x.
-
upto(c,s,i1,i2) : i3,i4,...,in # locate characters
Generates the sequence of integer positions in s preceding a character
of c in s[i1:i2]. It fails if there is no such position.
Defaults:
s &subject
i1 &pos if s defaulted, otherwise 1
i2 0
-
variable(s) : x # produce variable
Produces the variable for the identifier or keyword named s, but fails
if there is no such variable. Local identifiers override global
identifiers.
-
where(f) : i # produce position in file
Produces the current byte position in f. The first byte in the file is
at position 1.
-
write(x1,x2,...,xn) : xn # write line
Writes strings x1,x2,...,xn with a line termination sequence added at
the end. If xi is a file, subsequent output is to xi. Initial output
is to standard output.
Default:
xi "" (empty string)
-
writes(x1,x2,...,xn) # write string
Writes strings x1,x2,...,xn without a line termination sequence added
at the end. If xi is a file, subsequent output is to xi. Initial
output is to standard output.
Default:
xi "" (empty string)
-
icont -- Icon translator and linker
icont [option...] file...
-c # translate only (no link)
-o file # name icode file "file"
-s # suppress progress messages
-t # give &trace initial value of -1
-u # issue warnings for undeclared identifiers
-Stn # change translator or linker table size
# (t is table ID, n is number of storage units)
Table IDs and defaults for -S option
====================================
Table ID Table Name Default Size
-------- ---------- ------------
c constant table 100
f field table 100
g global symbol table 200
i identifier table 500
l local symbol table 100
n line number table 1000
r record table 100
s string space 20000
t tree space 15000
C code buffer 15000
F file names 10
L labels 500
See also:
ihelp iconx
-
iconx -- Icon interpreter
The Icon interpreter is normally invoked automatically when the name of
an Icon program is entered as a command, but it can be invoked
explicitly, too.
iconx icode_file_name [arguments for Icon program.]
Shell environment variables recognized by iconx
===============================================
Name Default Description
-------- ------- -----------------------
TRACE 0 Initial value for &trace.
NOERRBUF undefined If set, &errout is not buffered.
STRSIZE 65000 Initial size (bytes) of string region
(strings).
BLOCKSIZE 65000 Initial size (bytes) of block region
(most objects).
COEXPSIZE 2000 Size (long words) of co-expression blocks.
MSTKSIZE 10000 Size (long words) of main interpreter stack.
STATSIZE 20480 Initial size (bytes) of static region
(co-expression blocks).
STATINCR 1/4 of Increment used to expand static region.
STATSIZE
See also:
ihelp icont
-
Expressions shown in order of decreasing precedence. Items in groups
(as separated by empty lines) have equal precedence.
High Precedence Expressions
(expr) # grouping
{expr1;expr2;...} # compound
x(expr1,expr2,...) # invocation
x{expr1,expr2,...} # "
[expr1,expr2,...] # list
expr.f # field reference
expr1[expr2] # subscript
expr1[expr2:expr3] # section
expr1[expr2+:expr3] # "
expr1[expr2-:expr3] # "
Prefix Expressions
not expr # success/failure reversal
| expr # repeated alternation
! expr # element generation
* expr # size
+ expr # numeric value
- expr # negative
. expr # value (dereference)
/ expr # null
\ expr # non-null
= expr # match and tab
? expr # random value
~ expr # cset complement
@ expr # activation
^ expr # refresh
Infix Expressions
expr1 \ expr2 # limitation
expr1 @ expr2 # transmission
expr1 ! expr2 # invocation
expr1 ^ expr2 # power
expr1 * expr2 # product
expr1 / expr2 # quotient
expr1 % expr2 # remainder
expr1 ** expr2 # intersection
expr1 + expr2 # sum
expr1 - expr2 # numeric difference
expr1 ++ expr2 # union
expr1 -- expr2 # cset or set difference
expr1 || expr2 # string concatenation
expr1 ||| expr2 # list concatenation
expr1 < expr2 # numeric comparison
expr1 <= expr2 # "
expr1 = expr2 # "
expr1 >= expr2 # "
expr1 > expr2 # "
expr1 ~= expr2 # "
expr1 << expr2 # string comparison
expr1 <<= expr2 # "
expr1 == expr2 # "
expr1 >>= expr2 # "
expr1 >> expr2 # "
expr1 ~== expr2 # "
expr1 === expr2 # value comparison
expr1 ~=== expr2 # "
expr1 | expr2 # alternation
expr1 to expr2 by expr3 # integer generation
expr1 := expr2 # assignment
expr1 <- expr2 # reversible assignment
expr1 :=: expr2 # exchange
expr1 <-> expr2 # reversible exchange
expr1 op:= expr2 # (augmented assignments)
expr1 ? expr2 # string scanning
expr1 & expr2 # conjunction
Low Precedence Expressions
break [expr] # break from loop
case expr0 of { # case selection
expr1:expr2
...
[default:exprn]
}
create expr # co-expression creation
every expr1 [do expr2] # iterate over generated values
fail # failure of procedure
if expr1 then exp2 [else exp3] # if-then-else
next # go to top of loop
repeat expr # loop
return expr # return from procedure
suspend expr1 [do expr2] # suspension of procedure
until expr1 [do expr2] # until-loop
while expr1 [do expr2] # while-loop
-
Functions and datatypes of arguments and produced values:
abs(N) : N # compute absolute value
acos(r1) : r2 # compute arc cosine
any(c,s,i1,i2) : i3 # locate initial character
args(p) : i # get number of procedure arguments
bal(c1,c2,c3,s,i1,i2) : i3,i4,...,in # locate balanced characters
callout(x,x1,x2,...,xn) : xm # call external function
center(s1,i,s2) : s3 # position string at center
char(i) : s # produce character
close(f) : f # close file
collect(i1,i2) : n # perform garbage collection
copy(x1) : x2 # copy value
cos(r1) : r2 # compute cosine
cset(x) # convert to cset
delete(X,y) : X # delete element
detab(s1,i1,i2,...,in) : s2 # remove tabs
display(i,f) : n # display variables
dtor(r1) : r2 # convert degrees to radians
entab(s1,i1,i2,...,in) : s2 # insert tabs
errorclear() : n # clear error indication
exit(i) # exit program
exp(r1) : r2 # compute exponential
find(s1,s2,i1,i2) : i3,i4,...,in # find string
get(L) : x # get value from list
getenv(s1) : s2 # get value of environment variable
iand(i1,i2) : i3 # compute bit-wise "and"
icom(i1) : i2 # compute bit-wise complement
image(x) : s # produce string image
insert(X,x1,x2) : X # insert element
integer(x) : i # convert to integer
ior(i1,i2) : i3 # compute bit-wise inclusive "or"
ishift(i1,i2) : i3 # shift bits
ixor(i1,i2) : i3 # compute bit-wise exclusive "or"
key(T) : x1,x2,...,xn # generate keys from table
left(s1,i,s2) : s3 # position string at left
list(i,x) : L # create list
log(r1,r2) : r3 # compute logarithm
many(c,s,i1,i2) : i3 # locate many characters
map(s1,s2,s3) : s4 # map characters
match(s1,s2,i1,i2) : i3 # match initial string
member(X,x) : x # test for membership
mmout(x) : n # write text to allocation history
mmpause(s) : n # write pause to allocation history
mmshow(x,s) : n # redraw in allocation history
move(i) : s # move scanning position
name(x) : s # produce name
numeric(x) : N # convert to numeric
open(s1,s2) : f # open file
ord(s) : i # produce ordinal
pop(L) : x # pop from list
pos(i1) : i2 # test scanning position
proc(x,i) : p # convert to procedure
pull(L) : x # pull from list
push(L,x) : L # push onto list
put(L,x) : L # put onto list
read(f) : s # read line
reads(f,i) : s # read string
real(x) : r # convert to real
remove(s) : n # remove file
rename(s1,s2) : n # rename file
repl(s1,i) : s2 # replicate string
reverse(s1) : s2 # reverse string
right(s1,i,s2) : s3 # position string at right
rtod(r1) : r2 # convert radians to degrees
runerr(i,x) # terminate with run-time error
save(s) : i # save executable image
seek(f,i) : f # seek to position in file
seq(i1,i2) : i3,i4,... # generate sequence of integers
set(L) : S # create set
sin(r1) : r2 # compute sine
sort(X,i) : L # sort structure
sqrt(r1) : r2 # compute square root
stop(x1,x2,...,xn) # stop execution
string(x) : s # convert to string
system(s) : i # call system function
tab(i) : s # set scanning position
table(x) : T # create table
tan(r1) : r2 # compute tangent
trim(s1,c) : s2 # trim string
type(x) : s # produce type name
upto(c,s,i1,i2) : i3,i4,...,in # locate characters
variable(s) : x # produce variable
where(f) : i # produce position in file
write(x1,x2,...,xn) : xn # write line
writes(x1,x2,...,xn) # write string
-
Operations and required datatypes
prefix operations
+N : N # compute positive
-N : N # compute negative
~c1 : c2 # compute cset complement
=s1 : s2 # match string in scanning
@C : x # activate co-expression
^C1 : C2 # create refreshed co-expression
*x : i # compute size
?x1 : x2 # generate random value
!x : x1,x2,...,xn # generate values
/x : x # check for null value
\x : x # check for non-null value
.x : x # dereference variable
infix operations
N1 + N2 : N3 # compute sum
N1 - N2 : N3 # compute difference
N1 * N2 : N3 # compute product
N1 / N2 : N3 # compute quotient
N1 % N2 : N3 # compute remainder
N1 ^ N2 : N3 # compute exponential
x1 ++ x2 : x3 # compute cset or set union
x1 -- x2 : x3 # compute cset or set difference
x1 ** x2 : x3 # compute cset or set intersection
s1 || s2 : s3 # concatenate strings
L1 ||| L2 : L3 # concatenate lists
R.f : x # get field of record
x1 @ C : x2 # transmission value to co-expression
x1 & x2 : x2 # evaluate in conjunction
N1 < N2 : N2 # compare numerically
N1 <= N2 : N2 # "
N1 = N2 : N2 # "
N1 >= N2 : N2 # "
N1 > N2 : N2 # "
N1 ~= N2 : N2 # "
s1 << s2 : s2 # compare lexically
s1 <<= s2 : s2 # "
s1 == s2 : s2 # "
s1 >>= s2 : s2 # "
s1 >> s2 : s2 # "
s1 ~== s2 : s2 # "
x1 === x2 : x2 # compare values
x1 ~=== x2 : x2 # "
x1 := x2 : x1 # assign value
x1 op:= x2 : x1 # augmented assignment
x1 :=: x2 : x1 # exchange values
x1 <- x2 : x1 # assign value reversibly
x1 <-> x2 : x1 # exchange values reversibly
-
Keywords
&ascii: c # cset of ascii characters
&clock : s # current time of day
&collections : i1,i2,i3,i4 # collection count generation
# (total,static,string,block)
&cset : c # cset of all characters
¤t : C # current co-expression
&date : s # current date
&dateline : s # current date and time
&digits : c # cset of digits 0-9
&error : i # run-time error conversion control
&errornumber : i # run-time error number
&errortext : x # run-time error message text
&errorvalue # run-time error offending value
&errout # standard error output file
&fail # fails
&features # implementation features generation
&file # current source code file name
&host # string identifying host computer
&input # standard input file
&lcase # cset of lower case letters a-z
&level # level of current procedure call
&line # current source code line number
&main # main co-expression
&null # the null value
&output # standard output file
&pos # string scanning position
&random # random number seed
®ions # current region size generation
# (static,string,block)
&source # activator of current co-expression
&storage # spaced used generation
# (static,string,block)
&subject # string scanning subject
&time # current run time in milliseconds
&trace # procedure tracing control
&ucase # cset of upper case letters A-Z
&version # version of Icon
-
Datatypes
null string co-expression table
integer cset procedure set
real file list (record types)
-
Reserved words
break do global next repeat to
by else if not return until
case end initial of static while
create every link procedure suspend
default fail local record then
-
Escapes in string and cset constants
\b backspace \v vertical tab
\d delete(rubout \' single quote
\e escape (altmode) \" double quote
\f formfeed \\ backslash
\l linefeed (newline) \ddd octal code
\n newline (linefeed) \xdd hexadecimal code
\r carriage return \^c control code
\t horizontal tab
-
Abbreviations used in Icon help files (and other Icon literature)
c cset C co-expression
f file L list
i integer N numeric (i or f)
n null R record (any record type)
p procedure S set
r real T table
s string X any structure type (L, R, S, or T)
x any type
-
About the Icon Programming Language Help File
Information used in this help file was obtained from the following
sources:
Griswold, Ralph E. and Madge T. Griswold. "The Icon Programming
Language, Second Edition", Prentice-Hall, Inc., Englewood Cliffs, New
Jersey. 1990.
Griswold, Ralph E. ICONT(1), manual page for "UNIX Programmer's
Manual", Department of Computer Science, The University of Arizona.
1988.
Further information on the Icon Programming Language can be obtained
from:
Icon Project
Department of Computer Science
Gould-Simpson Building
The University of Arizona
Tucson, Arizona 85721
U.S.A.
(602) 621-2018
icon-project@cs.arizona.edu (Internet)
...{uunet,allegra,noao}!arizona!icon-project (uucpnet)
August 3, 1990.
