372 lines
11 KiB
C
372 lines
11 KiB
C
/* @(#)io_stream.h 1.1 94/10/31 SMI */
|
|
|
|
/*
|
|
* Copyright (c) 1985 by Sun Microsystems, Inc.
|
|
*/
|
|
|
|
#ifndef suntool_io_stream_DEFINED
|
|
#define suntool_io_stream_DEFINED
|
|
#include <sunwindow/sun.h>
|
|
|
|
#ifndef makedev
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
|
|
/* TYPES */
|
|
|
|
struct input_ops_vector {
|
|
int (*str_getc) (); /* (struct Stream *in)
|
|
* Note: it is the responsibility of the
|
|
* implementor of the stream to return EOF
|
|
* to indicate that the stream is empty,
|
|
* and to insure that subsequent attempts
|
|
* to read from that stream will continue
|
|
* to return EOF.
|
|
*/
|
|
int (*ungetc) (); /* (char c, struct Stream *in)
|
|
* implementor only responsible for
|
|
* for putting back characters that were there.
|
|
* should return EOF if was unable to put back
|
|
* the character.
|
|
* Note: if not provided by implementor,
|
|
* i.e., ungetc = NULL, will be supplied
|
|
* by stream package first time it is required.
|
|
*** NOT IMPLEMENTED YET ***
|
|
* See comment regarding ungetc below.
|
|
*/
|
|
char *(*str_fgets) ();/* (char *, n, struct Stream *in)
|
|
* reads n-1 characters, or up to a newline
|
|
* character, whichever comes first,
|
|
* from the stream in into the string s.
|
|
* The last character read into s is
|
|
* followed by a null character.
|
|
* The newline is included. * returns NULL on end of file or error.
|
|
* not every stream will implement this
|
|
* procedure. For those that don't, the
|
|
* equivalent n calls to str_getc will be
|
|
* performed.
|
|
*/
|
|
int (*chars_avail) (); /* (struct Stream *in) */
|
|
struct posrec (*get_pos) (); /* (struct Stream *in)
|
|
* returns postion record consisting of
|
|
* line number and character position,
|
|
* character position is how many characters have been read.
|
|
* this is the value to give to set_pos
|
|
* if lineno = -1, means stream doesn't know
|
|
* lineno. This can occur after having
|
|
* reset with set_pos
|
|
*/
|
|
int (*set_pos) (); /* (int n, struct Stream *in)
|
|
* not every input stream will implement this
|
|
* procedure. returns -1 if not implemented
|
|
* or some other failure.
|
|
*/
|
|
|
|
void (*close) (); /* (struct Stream *in) */
|
|
};
|
|
|
|
struct output_ops_vector {
|
|
int (*str_putc) (); /* (char c, struct Stream *out) */
|
|
void (*str_fputs) (); /* (char *, struct Stream *out)
|
|
* copies the null-terminated string s to out.
|
|
* does not append a newline
|
|
*/
|
|
struct posrec (*get_pos) (); /* (struct Stream *out) */
|
|
void (*flush) (); /* (struct Stream *out)
|
|
* can be defaulted to NULL = NOP
|
|
*/
|
|
void (*close) (); /* (struct Stream *stream) */
|
|
};
|
|
|
|
union Ops_Pointer {
|
|
struct input_ops_vector *input_ops;
|
|
struct output_ops_vector *output_ops;
|
|
};
|
|
|
|
enum Stream_Type {Input, Output};
|
|
|
|
struct Stream {
|
|
enum Stream_Type stream_type;
|
|
char *stream_class; /* e.g. "String_Input_Stream" */
|
|
union Ops_Pointer ops; /* the procedures that implement the stream */
|
|
struct Stream *backing_stream; /* for streams that are composed by layering one stream on top of the other, such as filtered_comments_stream. Allows clients to get at the lower stream, e.g. to find out how many characters were seen at that level */
|
|
caddr_t client_data;
|
|
};
|
|
|
|
struct posrec {
|
|
int lineno;
|
|
int charpos;
|
|
};
|
|
|
|
typedef struct Stream STREAM;
|
|
|
|
/* GENERIC INPUT FUNCTIONS */
|
|
|
|
int stream_getc();
|
|
/* int stream_getc(in)
|
|
* STREAM *in;
|
|
* int so can return EOF
|
|
*/
|
|
|
|
stream_ungetc();
|
|
/* char stream_ungetc(c, in)
|
|
* STREAM *in;
|
|
* char c;
|
|
* if stream does not implement ungetc, first time ungetc is called
|
|
* the stream will be redefined to be a layered stream which knows
|
|
* how to implement ungetc. This will also occur if client tries
|
|
* to put back a character other than the one that was just read
|
|
* and stream is unprepared to deal with
|
|
* this, e.g. a file stream.
|
|
*/
|
|
|
|
int stream_peekc();
|
|
/* int stream_peekc(in)
|
|
* struct Stream *in;
|
|
* returns next character in stream without consuming it, i.e., the
|
|
* next call to getc or peekc will see the same character
|
|
* int so can return EOF. uses ungetc
|
|
*/
|
|
|
|
char *stream_gets();
|
|
/* char *stream_gets(s, in)
|
|
* char *s;
|
|
* STREAM *in;
|
|
* analagous to gets:
|
|
* reads characters from in until newline is read.
|
|
* Terminating newline character is not stored in s, and s is terminated
|
|
* with null character
|
|
* newlines preceded by \ are treated the same as any other character, i.e.
|
|
* both the \ and the newline are copied into s.
|
|
* if an error occurs, or if no characters are read, the value NULL is returned
|
|
*
|
|
|
|
char *stream_fgets();
|
|
/* char *stream_fgets(s, n, in)
|
|
* char *s;
|
|
* int n;
|
|
* struct Stream *in;
|
|
* analagous to fgets, i.e., like stream_gets, except newline is included
|
|
*/
|
|
|
|
int stream_chars_avail();
|
|
/* int chars_avail(in)
|
|
* struct Stream *in;
|
|
*/
|
|
|
|
stream_ungetstr();
|
|
/* stream_ungetstr(s, in)
|
|
* char *s;
|
|
* struct Stream *in;
|
|
|
|
*** NOT IMPLEMENTED YET ***
|
|
Implements "stuffing" of a sequence of characters.
|
|
redefines in so that the next n characters it returns are those in s.
|
|
Then in returns to its normal state. For a similar operation
|
|
involving another stream, see append_streams below.
|
|
*/
|
|
|
|
append_streams();
|
|
/* append_streams(in1, in2)
|
|
* struct Stream in1, in2;
|
|
*
|
|
*** NOT IMPLEMENTED YET ***
|
|
* redefines in2 so that characters are read from in1 until it returns EOF,
|
|
* then in2 is returned to its normal state, i.e. subsequent calls
|
|
* to getc will return characters from in2.
|
|
*/
|
|
|
|
int stream_set_pos();
|
|
/* int stream_position(n, stream)
|
|
* int n;
|
|
* STREAM *stream;
|
|
* positions stream so that next character read will be the nth character.
|
|
*/
|
|
|
|
#ifndef CHARCLASS /* also defined in io_streams.h */
|
|
#define CHARCLASS
|
|
enum CharClass {Break, Sepr, Other};
|
|
#endif
|
|
|
|
char *stream_get_token ();
|
|
/* char *stream_get_token (in, dest, charproc)
|
|
* struct Stream *in;
|
|
* char *dest;
|
|
* enum CharClass (*charproc) ();
|
|
|
|
* stream_get_token is used for tokenizing input, where more degree of
|
|
* flexibility is required than simply delimiting tokens by white spaces
|
|
* characters are divided into three classes, Break, Sepr, and Other.
|
|
* separators (Sepr) serve to delimit a token. Leading separators are skipped.
|
|
* think of separators as white space. Break characters delimit tokens, and
|
|
* are themselves tokens. Thus, if a break character is the first thing seen
|
|
* it is returned as the token. If any non-separator characters have been seen,
|
|
* then they are returned as the token, and the break character will be the
|
|
* returned as the result of the next call to get_token.
|
|
* for example, if charproc returns Sepr for space, and Break for '(' and ')'
|
|
* and Other for all alphabetic characters, then the string "now (is) the"
|
|
* will yield five tokens consisting of "now" "(" "is" ")" and "the"
|
|
|
|
* get_token stores the token that it constructs into dest,
|
|
* which is also returned as its value.
|
|
|
|
* get_token returns NULL, rather than the empty string, corresponding to
|
|
* the case where the token is empty
|
|
*/
|
|
|
|
|
|
void skip_over();
|
|
/* skip_over(in, charproc)
|
|
* struct Stream *in;
|
|
* enum CharClass (*charproc) ();
|
|
* reads and discards all characters from in for which charproc
|
|
* returns sepr.
|
|
* e.g. skip_over(in, white_space) skips over all white space
|
|
*/
|
|
|
|
#ifndef WHITESPACE
|
|
#define WHITESPACE
|
|
extern enum CharClass white_space();
|
|
/* returns sepr for blanks, newlines, and tabs, other for everything else */
|
|
#endif
|
|
|
|
|
|
#ifndef CHARACTION /* also defined in io_streams.h */
|
|
#define CHARACTION
|
|
struct CharAction {
|
|
Bool stop;
|
|
Bool include;
|
|
};
|
|
#endif
|
|
|
|
char * stream_get_sequence ();
|
|
/* char *stream_get_sequence (in, dest, charproc);
|
|
* struct Stream *in;
|
|
* char *dest;
|
|
* struct CharAction (*charproc) ();
|
|
|
|
* stream_get_sequence is a more primitive tokenizer than get_token.
|
|
* it takes a procedure which for each character specifies whether the
|
|
* character is to terminate the sequence, and whether or not the
|
|
* character is to be included in the sequence.
|
|
* (If the character terminates the sequence, but is not included, then
|
|
* it will be seen again on the next call.)
|
|
* For example, having seen a \"\, to read to the matching \"\, call
|
|
* get_sequence with an action procedure that returns {TRUE, TRUE} for \"\
|
|
* and {FALSE, TRUE} for everything else. (If you want to detect the
|
|
* case where a " is preceded by a \\, simply save the last character
|
|
* and modify the procedure accordingly.
|
|
|
|
* Note that gettoken can be defined in terms of get_sequence by
|
|
* having Other characters return {FALSE, TRUE}, and also noticing whether
|
|
* any have been seen yet, having Seprs return
|
|
* {(seen_some_others ? TRUE : FALSE), FALSE}
|
|
* and Break characters return {TRUE, (seen_some_others ? FALSE : TRUE)}
|
|
|
|
* returns NULL for the empty sequence
|
|
*/
|
|
|
|
#ifndef EVERYTHING
|
|
#define EVERYTHING
|
|
struct CharAction everything();
|
|
/* returns {FALSE, TRUE} for all characters */
|
|
#endif
|
|
|
|
|
|
/* GENERIC OUTPUT FUNCTIONS */
|
|
|
|
int stream_putc();
|
|
/* stream_putc(c, out)
|
|
* char c;
|
|
* struct Stream *out;
|
|
* returns c if successful, otherwise EOF
|
|
*/
|
|
|
|
void stream_puts();
|
|
/* stream_puts(s, out)
|
|
* char *s;
|
|
* struct Stream *out;
|
|
* analagous to puts:
|
|
* writes s to out until a null is encountered (which is not written).
|
|
* then writes a newline.
|
|
*/
|
|
|
|
void stream_fputs();
|
|
/* stream_fputs(s, out)
|
|
* char *s;
|
|
* struct Stream *out;
|
|
* analagous to fputs, i.e. like stream_puts but does not include newline
|
|
*/
|
|
|
|
|
|
/* GENERIC FUNCTIONS THAT APPLY TO BOTH INPUT AND OUTPUT */
|
|
|
|
void stream_close();
|
|
/* void stream_close(stream)
|
|
* struct Stream *stream;
|
|
*/
|
|
|
|
struct posrec stream_get_pos();
|
|
/* int stream_position(stream)
|
|
* STREAM *stream;
|
|
* returns number of lines and characters read from/ written to stream
|
|
* lineno = -1, means stream doesn't know line number. This occurs
|
|
* if stream has been reset via setpos, or implementor simply doesn't
|
|
* bother to keep count
|
|
* Note also that lineno may be inaccurate if someone calls puts
|
|
* on a string which contains a newline in the middle somewhere.
|
|
*/
|
|
|
|
void stream_flush();
|
|
/* void stream_flush(out)
|
|
* struct Stream *out;
|
|
*/
|
|
|
|
|
|
/* VARIOUS STREAM TYPES */
|
|
|
|
struct Stream *string_input_stream();
|
|
/* struct Stream *string_input_stream(s, in)
|
|
* char *s;
|
|
* struct Stream *in;
|
|
if in = NULL, creates new one, otherwise reuses this one
|
|
*/
|
|
|
|
struct Stream *string_output_stream();
|
|
/* struct Stream *string_output_stream(s, out)
|
|
* char *s;
|
|
* struct Stream *out;
|
|
if out = NULL, creates new one, otherwise reuses this one
|
|
*/
|
|
|
|
struct Stream *file_input_stream();
|
|
/* struct Stream *file_input_stream(s, fp)
|
|
* char *s;
|
|
* FILE *fp;
|
|
* if fp != NULL, it is used and s is ignored, otherwise
|
|
* s is opened using fopen, with nmode "r"
|
|
* e.g. file_input_stream(NULL, STDIN) works.
|
|
*/
|
|
|
|
struct Stream *file_output_stream();
|
|
/* struct Stream *file_output_stream(s, fp, append)
|
|
* char *s;
|
|
* FILE *fp;
|
|
* Bool append;
|
|
* if fp != NULL, it is used and s is ignored, otherwise
|
|
* s is opened using fopen and mode "w" is append is FALSE, otherwise "a"
|
|
* e.g. file_output_stream(NULL, stdout) works.
|
|
*/
|
|
|
|
struct Stream *filter_comments_stream();
|
|
/* struct Stream *filter_comments_stream(in)
|
|
* struct Stream *in;
|
|
* creates a stream that obtains its input from in and discards all
|
|
* characters that are inside of comments, where a comment is either
|
|
* a line that begins with a #, or a sequence of characters bracketed by
|
|
* slash* and *slash.
|
|
*/
|
|
|
|
#endif
|