iolib

UNIX版本6的源代码

It is possible to direct output to a string instead of to a file.
This is indicated by \(mi1 as the first argument.
The second argument should be a pointer to the string.
\fIPrintf\fR will put a terminating `\\0' onto the string.
.sn
SCANF (\|[fd, ] control-string, arg1, arg2, ....)
.sp .5
SCANF (\|[\(mi1, input-string, ] control-string, arg1, arg2, ....)
.sN
.ft I
Scanf
.ft R
reads characters, interprets
them according to a format, and stores the results in its arguments.
It expects as arguments:
.ti 5
.ti -0.2i
1.	An optional file-descriptor or input-string, indicating the source of the input
characters; if omitted, file
.I
cin
.R
is used;
.ti -0.2i
2.	A control string, described below;
.ti -0.2i
3.	A set of arguments,
.ft I
each of which must be a pointer,
.ft R
indicating where the converted input should be stored.
.in 0
.sp 5p
The
control string
usually contains
conversion specifications, which are used to direct interpretation
of input sequences.
The control string may contain:
.sp 5p
.in 5
.ti -0.2i
1.	Blanks, tabs or newlines, which are ignored.
.ti -0.2i
2.	Ordinary characters (not %) which are expected to match
the next non-space character of the input stream
(where space characters are defined as blank, tab or newline).
.ti -0.2i
3.	Conversion specifications, consisting of the
character %, an optional assignment suppressing character \**,
an optional numerical maximum field width, and a conversion
character.
.in 0
.sp 5p
A conversion specification is used to direct the conversion of the
next input field; the result
is placed in the variable pointed to by the corresponding argument,
unless assignment suppression was
indicated by the \** character.
An input field is defined as a string of non-space characters;
it extends either to the next space character or until the field
width, if specified, is exhausted.
.PP
The conversion character indicates the interpretation of the
input field; the corresponding pointer argument must
usually be of a restricted type.
Pointers, rather than variable names, are required
by the ``call-by-value'' semantics of the C language.
The following conversion characters are legal:
.in 5
.ti -0.2i
\fB%\fR	indicates that a single % character is expected
in the input stream at this point;
no assignment is done.
.tr @ 
.ti -0.2i
\fBd\fR	indicates that a decimal integer is expected
in the input stream;
the corresponding argument should be an integer pointer.
.ti -0.2i
\fBo\fR	indicates that an octal integer is expected in the
input stream; the corresponding argument should be a integer pointer.
.ti -0.2i
\fBx\fR	indicates that a hexadecimal integer is expected in the input stream;
the corresponding argument should be an integer pointer.
.ti -0.2i
\fBs\fR	indicates that a character string is expected;
the corresponding argument should be a character pointer
pointing to an array of characters large enough to accept the
string and a terminating `\\0', which will be added.
The input field is terminated by a space character
or a newline.
.ti -0.2i
\fBc\fR	indicates that a single character is expected; the
corresponding argument should be a character pointer;
the next input character is placed at the indicated spot.
The normal skip over space characters is suppressed
in this case;
to read the next non-space character, try
.ft I
%1s.
.ft R
.ti -0.2i
\fBe\fR or \fBf\fR indicates that a floating point number is expected in the input stream;
the next field is converted accordingly and stored through the
corresponding argument, which should be a pointer to a float.
The input format for
.I
floats
.R
is
a string of numbers
possibly containing a decimal point, followed by an optional
exponent field containing an E or e followed by a possibly signed integer.
.ti -0.2i
\fB[\fR	indicates a string not to be delimited by space characters.
The left bracket is followed by a set of characters and a right
bracket; the characters between the brackets define a set
of characters making up the string.
If the first character
is not circumflex (\|^\|), the input field
is all characters until the first character not in the set between
the brackets; if the first character
after the left bracket is ^, the input field is all characters
until the first character which is in the remaining set of characters
between the brackets.
The corresponding argument must point to a character array.
.in 0
.PP
The conversion characters
.I
d, o
.R
and
.I
x
.R
may be preceded by 
.I
l
.R
to indicate that a pointer to
.I
long
.R
rather than
.I
int
.R
is expected.
Similarly, the conversion characters
.I
e
.R
or
.I
f
.R
may be preceded by
.I
l
.R
to indicate that a pointer to 
.I
double
.R
rather than 
.I
float
.R
is in the argument list.
The character
.I
h
.R
will function similarly in the future to indicate
.I
short
.R
data items.
.PP
For example, the call
.in 10
.nf
.ft I
int i; float x; char name[50];
scanf ( ``%d%f%s'', &i, &x, name);
.ft R
.in 0
with the input line
.in 10
.ft I
25   54.32E\(mi1  thompson
.ft R
.in 0
.fi
will assign to
.ft I
i
.ft R
the value
25,
.ft I
x
.ft R
the value 5.432, and
.ft I
name
.ft R
will contain
.ft I
``thompson\\0''.
.ft R
Or,
.ft I
.nf
.in 10
int i; float x; char name[50];
scanf (``%2d%f%\**d%[1234567890]'', &i, &x, name);
.ft R
.in 0
with input
.ft I
.in 10
56789 0123 56a72
.ft R
.in 0
.fi
will assign 56 to
.ft I
i,
.ft R
789.0 to
.ft I
x,
.ft R
skip ``0123'',
and place the string ``56\\0'' in
.ft I
name.
.ft R
The next call to \fIcgetc\fR will return `a'.
.PP
.ft I
Scanf
.ft R
returns as its value the number of successfully matched and assigned input
items.
This can be used to decide how many input items were found.
On end of file, \(mi1 is returned; note that this is different
from 0, which means that the next input character does not
match what you called for in the control string.
.ft I
Scanf,
.ft R
if given a first argument of \(mi1, will scan a string in memory
given as the second argument.  For example,
if you want to read up to four numbers from an input line
and find out how many there were, you could try
.ft I
.in 5
.nf
.ne 3
int a[4], amax;
char line[100];
amax = scanf (\(mi1, gets(line), ``%d%d%d%d'', &a[0], &a[1], &a[2], &a[3]);
.in 0
.ft R
.fi
.SH
6. BINARY STREAM ROUTINES
.PP
These routines write binary data, not translated to printable characters.
They are normally efficient
but do not produce files that can be printed or easily interpreted.
No special information is added
to the records and thus they can be handled by
other programming systems
.ft I
if
.ft R
you make the departure from portability required
to tell the other system how big a C item (integer, float,
structure, etc.) really is in machine units.
.sn
COPEN (name, direction, ``i'')
.sN
When
.ft I
copen
.ft R
is called with a third argument as above, a binary stream
filedescriptor is returned.
Such a file descriptor is required for the remaining
subroutines in this section, and may not be used with
the routines in the preceding two sections.
The first two arguments operate exactly as described in section
3;
further details are given in section 7.
An ordinary file descriptor may be used for binary I-O,
but binary and character I-O may not be mixed
unless
.I
cflush
.R
is called at each switch to binary I-O.
The third
argument to
.I
copen
.R
is ignored.
.sn
CWRITE (\|ptr, sizeof(\**ptr), nitems, fd\|)
.sN
.ft I
Cwrite
.ft R
writes
.ft I
nitems
.ft R
of data beginning at
.ft I
ptr
.ft R
on file
.ft I
fd.
Cwrite
.ft R
writes blocks of binary information, not translated to
printable form, on a file.  It is intended for machine-oriented
bulk storage of intermediate data.  Any kind of data may
be written with this command, but only the corresponding
.ft I
cread
.ft R
should be expected to make any sense of it on return.
The first argument is a pointer to the beginning of a vector
of any kind of data.  The second argument
tells
.ft I
cwrite
.ft R
how big the items are.
The third argument specifies the number
of the items to be written; the fourth indicates where.
.sn
CREAD (\|ptr, sizeof(\**ptr), nitems, fd\|)
.sN
.ft I
Cread
.ft R
reads up to
.ft I
nitems
.ft R
of data from file
.ft I
fd
.ft R
into a buffer beginning at
.ft I
ptr.
Cread
.ft R
returns the number of items read.
.br
.ne 2i
The returned
number of items will be equal to the number requested by
.I
nitems
.R
except for reading certain devices (e.g. the teletype or magnetic tape)
or reading the final bytes of a disk file.
.LP
Again, the second argument indicates the size
of the data items being read.
.sn
CCLOSE (fd)
.sN
The same description applies as for
character-stream files.
.SH
7. OTHER PORTABLE ROUTINES
.LP
.sn
REW (fd)
.sN
Rewinds unit
.I
fd.
.R
Buffers are emptied properly and the file
is left open.
.sn
SYSTEM (string)
.sN
The given
.I
string
.R
is executed as if it were typed at the terminal.
.sn
NARGS (\|)
.sN
A subroutine can call
this function to try to find out how many arguments it was called with.
Normally,
.I
nargs()
.R
returns the number of arguments
plus 3 for every
.I
float
.R
or
.I
double
.R
argument
and plus one for every
.I
long
.R
argument.
If the new \*sUNIX\*S feature of separated instruction and data space
areas is used,
.I
nargs()
.R
doesn't work at all.
.sn
CALLOC (n, sizeof(object))
.sN
.I
Calloc
.R
returns a pointer to new storage, allocated in space
obtained from the operating system.
The space obtained is
well enough aligned for any use, i.e.
for a double-precision number.
Enough space to store
.I
n
.R
objects of the size
indicated by the second argument
is provided.
The
.I
sizeof
.R
is executed at compile time; it is not in the library.
A returned value of \(mi1 indicates failure to obtain space.
.sn
CFREE (ptr, n, sizeof(*ptr))
.sN
.I
Cfree
.R
returns to the operating system
memory starting at
.I
ptr
.R
and extending for
.I
n
.R
units of the size given by the third argument.
The space should have been obtained through \fIcalloc\fR.
On \*sUNIX\*S you can
only return the exact amount of space
obtained by 
.I
calloc;
.R
the second and third arguments are ignored.
.sn
FTOA (floating-number, char-string, precision, format\|)
.sN
.ft I
Ftoa
.ft R
(floating to \*sASCII\*S conversion)
converts floating point numbers to character strings.
The
.ft I
format
.ft R
argument should be either `f' or `e'; `e' is default.
See the explanation of
.ft I
printf
.ft R
in section 5 for a description of the result.
.sn
ATOF (char-string)
.sN
Returns a floating value equal to the
value of the \*sASCII\*S character string argument,
interpreted as a decimal floating point number.
.sn
TMPNAM (str)
.sN
This routine places in the character array expected as its argument
a string
which is legal to use as a file name
and which is guaranteed to be unique
among all jobs executing on the computer at the same
time.  It is thus appropriate for use as a temporary
file name, although
the user may wish to move it into an appropriate directory.
The value of the function is the address
of the string.
.sn
ABORT (code)
.sN
Causes your program to terminate abnormally, which typically
results in a dump by the operating system.
.sn
INTSS ()
.sN
This routine tells you whether you are running in
foreground or background.
The definition of ``foreground'' is that
the standard input is the terminal.
.sn
WDLENG (\|)
.sN
This returns 16 on \*sUNIX\*S.
C users should be aware that the preprocessor
normally provides a defined symbol suitable for distinguishing the local system;
thus on
.SM
UNIX
.NL
the symbol
.I
unix
.R
is defined
before starting to compile your program.